Web Accessibility Rules in C#

Use the AccessibilityRules repository to access WCAG-related principles, guidelines, success criteria, and techniques in C#. Select rules by code, pass them to CreateValidator(), and validate only the accessibility checks your workflow needs.

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-related requirements, success criteria, and techniques. Its structure corresponds to the WCAG Quick Reference. 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:

// Retrieve and list accessibility rules by code with their descriptions from the rules repository

// 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
string[] 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
IList<IRule> rules = webAccessibility.Rules.GetRules(rulesCodes);

// Get code and description of rule
foreach (IRule 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:

// Retrieve and display the code and description of an accessibility principle by its code

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

// Retrieve and display the code and description of an accessibility guideline

// 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);  // 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 is the success criteria from the standard – not the techniques.

Verifiable success criteria are provided for each recommendation so WCAG 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() method to access criteria from guideline:

// Retrieve and display the code and description of an accessibility criterion

// Initialize a webAccessibility container
WebAccessibility 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 (IRule technique in criterion.SufficientTechniques)
        Console.WriteLine("{0}:{1}", technique.Code, technique.Description);
}

Check HTML Against Specific Web Accessibility Rules

This example demonstrates how to validate an HTML document for web accessibility using a specified set of rule codes:

• 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.

// Validate an HTML document using specific rule codes with C#

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

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

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

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

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

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

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

FAQ

How do I get accessibility rules by code?

Use WebAccessibility.Rules.GetRules() and pass the required rule codes, such as H37, H67, or 1.1.1.

What is the difference between a criterion and a technique?

A criterion defines the WCAG success condition. A technique describes one possible way to satisfy that criterion or detect a failure.

Should I validate all rules or a selected rule list?

Use all rules for broad audits. Use selected rule codes when you need a focused check, faster review, or validation for a specific accessibility requirement.

Related Articles

• Accessibility Validator in C# – create validators and configure accessibility checks.
• Validation Results in C# – inspect ValidationResult, RuleValidationResult, and technique details.
• Accessibility Errors and Warnings in C# – collect issue messages and target elements after validation.
• Web Accessibility Check in C# – validate HTML documents for accessibility and inspect WCAG-related results.
• How to Improve Website Accessibility – improve alt text, captions, semantic HTML, keyboard access, and forms.

You can also use the online Web Accessibility Checker for a quick page-level accessibility scan.