Web Accessibility Rules – Website Accessibility Check in C#

Aspose.HTML for .NET provides the Aspose.Html.Accessibility namespace, which is intended for all Web Accessibility related manipulations and checks. In this article, you will learn how to use the AccessibilityRules class, which is a repository of WCAG 2.0requirements, success criteria, and techniques.

You can learn how to use the AccessibilityValidator class to check web accessibility from the article Accessibility Validator – Website Accessibility Check in C#.

Accessibility rules are a set of guidelines, standards, or best practices that define how digital content and interfaces should be designed and developed to ensure they are accessible to people with disabilities. These guidelines are intended to make digital content, such as websites, apps, and multimedia, accessible to a wide range of people, including those with visual, hearing, motor, and cognitive impairments. Accessibility rules are crucial for promoting digital inclusion and ensuring everyone has equal access to online information and services.

The structure of the quick reference can be presented in the form of a diagram, which is indicated below:

The directory contains the rules that implement the IRule interface.

Accessibility Rules

The AccessibilityRules class is a repository of WCAG 2.0 requirements, success criteria, and techniques and has a structure that corresponds to the specification WCAG (Quick Reference) and is loaded using the WebAccessibilityDataSource class. The class has an internal constructor. Therefore users cannot directly create an object of the class. In order to view the list of rules, you need to initialize the WebAccessibility container and use the property Rules.

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

    // Get the accessibilityRules repository
    AccessibilityRules accessibilityRules = webAccessibility.Rules;

The property returns an object of type AccessibilityRules, which has such methods for accessing the rules:

Methods	Description
GetPrinciple(string code)	Returns Principle object by code from WCAG.
GetPrinciples()	Returns a list of principles IList< Principle>.
GetRules(params string[] codes)	Returns a list of rules IList< IRule> for given codes from WCAG.

The directory contains rules that inherit from the abstract class Rule. There are several types of rules:

• principle
• guideline
• criterion
• technique

IRule

All rules implement the interface IRule is a public interface that defines the basic properties of the rules:

Property	Description
Code	Rule code from the quick reference WCAG.
Description	Description of Rule from the quick reference WCAG.

Rule

The base abstract class for all rules, which implements the interface IRule. To get any rule, you can use the GetRules() method:

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

// List of rule codes can contain both technique codes and principles, guidelines and criteria - all rules that implement the interface IRule
var rulesCodes = new string[] { "H2", "H37", "H30", "1.1", "1.2.1" };

// Get a list of IRule objects; if a rule with the specified code is not found, it will not be in the list
var rules = webAccessibility.Rules.GetRules(rulesCodes);

// Get code and description of rule
foreach (var rule in rules)
    Console.WriteLine("{0}:{1}", rule.Code, rule.Description);

The program will output to the console:

    H2:Combining adjacent image and text links for the same resource
    H37:Using alt attributes on img elements
    H30:Providing link text that describes the purpose of a link for anchor elements
    1.1:Text Alternatives
    1.2.1:Audio-only and Video-only (Prerecorded)

Principle

At the first level of the list of rules are the Principles, they indicate the main direction and purpose of the rules that are in this section. Therefore, work with the directory begins with them.

The Principle class inherited from Rule and also contains a list of guidelines.

Method	Description
GetGuideline(string code)	Get Guideline by code from WCAG, contained in principle. Return Guideline object.
GetGuidelines()	Get a list of Guideline from Principle. Return IList< Guideline> object.

An example of how to get a Principle object from a list of rules:

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

// Get the principle by code
Principle rule = webAccessibility.Rules.GetPrinciple("1");

// Get code and description of principle
Console.WriteLine("{0}:{1}", rule.Code, rule.Description);  // output: 1:Perceivable      

Guideline

The Guideline class inherited from Rule and contains a criteria list. Guidelines are the next level after principles. They outline frameworks and general goals that help authors understand success criteria and better apply the techniques.

Method	Description
GetCriterion(string code)	Get Guideline by code from WCAG, contained in current Guideline. Return Criterion object.
GetCriterions()	Get a list of Criterion from current Guideline. Return IList< Criterion> object.

An example of how to get a Guideline object from a list of rules:

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

// Get the principle by code 
Principle principle = webAccessibility.Rules.GetPrinciple("1");

// Get guideline 1.1
Guideline guideline = principle.GetGuideline("1.1");
if (guideline != null)
{
    Console.WriteLine("{0}:{1}", guideline.Code, guideline.Description, guideline);  // output: 1.1:Text Alternatives
}

Criterion

The Criterion class describes the WCAG success criteria, inherited from abstract class Rule. Detailed information can be found here – Understanding Techniques for WCAG Success Criteria. The basis for determining conformance to WCAG 2.0 is the success criteria from the WCAG 2.0 standard – not the techniques.

Verifiable success criteria are provided for each recommendation so WCAG 2.0 can be applied in areas where compliance testing is required.

Property	Description
Level	Compliance levels: A (lowest), AA and AAA (highest).
SufficientTechniques	Returns list of Sufficient techniques that are reliable ways to meet the success criteria.
AdvisoryTechniques	Returns list of Advisory techniques that are suggested ways to improve accessibility. They are often very helpful to some users, and may be the only way that some users can access some types of content.
Failures	Returns list of Failures that are things that cause accessibility barriers and fail specific success criteria.

The criterion contains a list of techniques for meeting WCAG web content accessibility guidelines. If all sufficient methods for a given criterion are supported by accessibility, then the success criterion has passed.

Use the GetCriterion(string code) method to access criteria from guideline:

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

// Get the principle by code 
Principle principle = webAccessibility.Rules.GetPrinciple("1");

// Get guideline 
Guideline guideline = principle.GetGuideline("1.1");

// Get criterion by code
Criterion criterion = guideline.GetCriterion("1.1.1");
if (criterion != null)
{
    Console.WriteLine("{0}:{1} - {2}", criterion.Code, criterion.Description, criterion.Level); // output: 1.1.1:Non-text Content - A

    // Get all Sufficient Techniques and write to console
    foreach (var technique in criterion.SufficientTechniques)
        Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
}

Check HTML Against Specific Web Accessibility Rules

var htmlPath = Path.Combine(DataDir, "input.html");

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

// List of necessary rules for checking (rule code according to the specification) 
var rulesCode = new string[] { "H2", "H37", "H67", "H86" };

// Get the required IList<Rule> rules from the rules reference
var rules = webAccessibility.Rules.GetRules(rulesCode);

// Create an accessibility validator, pass the found rules as parameters, and specify the full validation settings
var validator = webAccessibility.CreateValidator(rules, ValidationBuilder.All);

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

    // Return the result in string format
    // SaveToString - return only errors and warnings
    Console.WriteLine(validationResult.SaveToString());
}

This code demonstrates how to validate an HTML document for web accessibility using the specified set of rules.

• Use the WebAccessibility() constructor to create the webAccessibility container, which manages the accessibility rules and validation.
• Define a list of rule codes (e.g., “H2”, “H37”, “H67”, “H86”) that correspond to the accessibility standards you want to validate against.
• Call the GetRules() method, passing the list of rule codes as a parameter.
• Create a validator by calling the CreateValidator() method on the webAccessibility container, passing the retrieved rules and the ValidationBuilder.All setting to configure the validation comprehensively.
• Load an HTML document you want to validate using one of the HTMLDocument() constructors.
• Use the Validate() method of the validator to check the loaded HTMLDocument against the defined rules, generating a ValidationResult object.
• Call the SaveToString() method on the ValidationResult object to format the results, including only the errors and warnings, as a string.
• Output the validation results to the console or save them as needed for further analysis or reporting.