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:

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());
}

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
    WebAccessibility 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);

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
    WebAccessibility 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);
    }

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:

     // Get 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);

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