Règles d'accessibilité du Web – Vérification de l'accessibilité des sites Web selon les WCAG

Aspose.HTML for .NET fournit l’espace de noms Aspose.Html.Accessibility, qui est destiné à toutes les manipulations et vérifications liées à l’accessibilité du Web. Dans cet article, vous apprendrez à utiliser la classe AccessibilityRules, qui est un référentiel d’exigences, de critères de réussite et de techniques WCAG 2.0.

Vous pouvez apprendre à utiliser la classe AccessibilityValidator pour vérifier l’accessibilité du web dans l’article Accessibility Validator.

Les règles d’accessibilité sont un ensemble de lignes directrices, de normes ou de bonnes pratiques qui définissent la manière dont le contenu numérique et les interfaces doivent être conçus et développés pour garantir leur accessibilité aux personnes handicapées. Ces lignes directrices visent à rendre le contenu numérique, tel que les sites web, les applications et le multimédia, accessible à un large éventail de personnes, y compris celles souffrant de déficiences visuelles, auditives, motrices et cognitives. Les règles d’accessibilité sont essentielles pour promouvoir l’inclusion numérique et garantir à tous un accès égal aux informations et aux services en ligne.

La structure de la référence rapide peut être présentée sous la forme d’un diagramme, qui est indiqué ci-dessous :

Le répertoire contient les règles qui mettent en œuvre l’interface IRule.

Règles d’accessibilité

La classe AccessibilityRules est un référentiel d’exigences, de critères de réussite et de techniques WCAG 2.0 et possède une structure qui correspond à la spécification WCAG (Quick Reference). Pour afficher la liste des règles, vous devez initialiser le conteneur WebAccessibility et utiliser la propriété Rules.

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

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

La propriété renvoie un objet de type AccessibilityRules, qui possède des méthodes d’accès aux règles :

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.

Le répertoire contient des règles qui héritent de la classe abstraite Rule. Il existe plusieurs types de règles :

• principle
• guideline
• criterion
• technique

IRule

Toutes les règles mettent en œuvre l’interface IRule, une interface publique qui définit les propriétés de base des règles :

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

Rule

Classe abstraite de base pour toutes les règles, qui met en œuvre l’interface IRule. Pour obtenir une règle, vous pouvez utiliser la méthode GetRules() :

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

Le programme affichera une sortie sur la 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)

Principe

Au premier niveau de la liste des règles se trouvent les principes, qui indiquent l’orientation principale et l’objectif des règles contenues dans cette section. C’est donc par eux que commence le travail avec le répertoire.

La classe Principe a hérité de la classe Rule et contient également une liste de lignes directrices.

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.

Exemple de récupération d’un objet Principe à partir d’une liste de règles :

// 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

La classe Guideline hérite de la classe Rule et contient une liste de critères. Les lignes directrices constituent le niveau suivant après les principes. Elles définissent des cadres et des objectifs généraux qui aident les auteurs à comprendre les critères de réussite et à mieux appliquer les 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.

Exemple de récupération d’un objet Guideline à partir d’une liste de règles :

// 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

La classe Criterion décrit les critères de réussite WCAG, hérités de la classe abstraite Rule. Des informations détaillées sont disponibles ici – Understanding Techniques for WCAG Success Criteria. La base de la détermination de la conformité aux WCAG 2.0 est constituée par les critères de réussite de la norme, et non par les techniques.

Des critères de réussite vérifiables sont fournis pour chaque recommandation afin que les WCAG 2.0 puissent être appliqués dans les domaines où des tests de conformité sont nécessaires.

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.

Le critère contient une liste de techniques permettant de respecter les lignes directrices des WCAG relatives à l’accessibilité du contenu web. Si toutes les méthodes suffisantes pour un critère donné sont compatibles avec l’accessibilité, le critère de réussite est validé.

Utilisez la méthode GetCriterion() pour accéder aux critères de la directive :

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

Vérifier le code HTML par rapport à des règles spécifiques d’accessibilité du Web

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

Ce code montre comment valider un document HTML pour l’accessibilité du web en utilisant l’ensemble des règles spécifiées.

• Utilisez le constructeur WebAccessibility() pour créer le conteneur webAccessibility, qui gère les règles d’accessibilité et la validation.
• Définissez une liste de codes de règles (par exemple, “H2”, “H37”, “H67”, “H86”) qui correspondent aux normes d’accessibilité que vous souhaitez valider.
• Appeler la méthode GetRules(), en passant la liste des codes de règles en paramètre.
• Créez un validator en appelant la méthode CreateValidator() sur le conteneur webAccessibility, en lui passant les règles récupérées et le paramètre ValidationBuilder.All pour configurer la validation de manière complète.
• Chargez un document HTML que vous souhaitez valider en utilisant l’un des constructeurs HTMLDocument().
• Utiliser la méthode Validate() du validator pour vérifier le HTMLDocument chargé par rapport aux règles définies, en générant un objet ValidationResult.
• Appeler la méthode SaveToString() sur l’objet ValidationResult pour formater les résultats, y compris les erreurs et les avertissements, sous forme de chaîne de caractères.
• Affichez les résultats de la validation sur la console ou enregistrez-les en vue d’une analyse ou d’un rapport ultérieur.

Voir aussi

• Dans le chapitre Vérification de l’accessibilité du Web, vous apprendrez à vérifier l’accessibilité d’un site Web pour qu’il soit conforme aux WCAG ou qu’il réponde uniquement à des critères spécifiques en utilisant les classes et les méthodes des espaces de noms Aspose.Html.Accessibility et Aspose.Html.Accessibility.Results.
• L’article Comment améliorer l’accessibilité d’un site Web explique comment rendre votre site Web accessible aux utilisateurs et comment vérifier la conformité de votre site aux WCAG à l’aide de l’API Aspose.HTML for .NET.
• L’article Accessibilité aux lecteurs d’écran explique comment concevoir un site web pour l’accessibilité aux lecteurs d’écran conformément aux directives WCAG en utilisant l’API Aspose.HTML for .NET.
• Consultez l’article Vérifier le contraste des couleurs en C# si vous souhaitez apprendre à ajuster correctement le contraste de votre contenu web conformément aux normes WCAG, l’autorité mondiale en matière d’accessibilité du web. Vous découvrirez comment tester l’accessibilité du contraste des couleurs à l’aide de C# et rendre votre contenu web facile à lire pour tous les utilisateurs.
• Dans l’article Accessibility Validator, vous découvrirez la classe AccessibilityValidator qui peut être utilisée pour tester les règles d’accessibilité du web telles que les principes, les lignes directrices et les critères.

Aspose.HTML propose gratuitement en ligne Vérificateur d’accessibilité Web. Cet outil analyse les pages web, valide leur conformité aux WCAG, identifie les problèmes et suggère des améliorations. Il vous permet de déterminer l’ampleur des corrections nécessaires et l’écart entre l’état actuel de votre site web ou de votre document HTML et les exigences des WCAG.