Reglas de accesibilidad web – verificación de accesibilidad del sitio web en C#

Aspose.HTML for .NET proporciona el espacio de nombres Aspose.Html.Accessibility, que está destinado a todas las manipulaciones y comprobaciones relacionadas con la accesibilidad web. En este artículo, aprenderá a utilizar la clase AccessibilityRules, que es un repositorio de requisitos, criterios de éxito y técnicas WCAG 2.0.

Puede aprender a utilizar la clase AccessibilityValidator para comprobar la accesibilidad web en el artículo Validador de accesibilidad.

Las reglas de accesibilidad son un conjunto de pautas, estándares o mejores prácticas que definen cómo se deben diseñar y desarrollar el contenido y las interfaces digitales para garantizar que sean accesibles para las personas con discapacidad. Estas pautas tienen como objetivo hacer que el contenido digital, como sitios web, aplicaciones y multimedia, sea accesible para una amplia gama de personas, incluidas aquellas con discapacidades visuales, auditivas, motoras y cognitivas. Las reglas de accesibilidad son cruciales para promover la inclusión digital y garantizar que todos tengan igual acceso a la información y los servicios en línea.

La estructura de la referencia rápida se puede presentar en forma de diagrama, el cual se indica a continuación:

El directorio contiene las reglas que implementan la interfaz IRule.

Reglas de accesibilidad

La clase AccessibilityRules es un repositorio de requisitos, criterios de éxito y técnicas WCAG 2.0 y tiene una estructura que corresponde a la especificación WCAG (Quick Reference). Para ver la lista de reglas, debe inicializar el contenedor WebAccessibility y utilizar la propiedad Rules.

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

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

La propiedad devuelve un objeto de tipo AccessibilityRules, que tiene los siguientes métodos para acceder a las reglas:

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.

El directorio contiene reglas que heredan de la clase abstracta Rule. Hay varios tipos de reglas:

• principle
• guideline
• criterion
• technique

IRule

Todas las reglas implementan la interfaz IRule es una interfaz pública que define las propiedades básicas de las reglas:

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

Rule

La clase abstracta base para todas las reglas, que implementa la interfaz IRule. Para obtener cualquier regla, puedes usar el método 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);

El programa saldrá a la consola:

    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

En el primer nivel de la lista de reglas se encuentran los Principios, estos indican la dirección principal y el propósito de las reglas que se encuentran en esta sección. Por lo tanto, el trabajo con el directorio comienza con ellos.

La clase Principle heredada de Rule y también contiene una lista de pautas.

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.

Un ejemplo de cómo obtener un objeto Principle de una lista de reglas:

// 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 clase Guideline heredada de Rule y contiene una lista de criterios. Las pautas son el siguiente nivel después de los principios. Describen marcos y objetivos generales que ayudan a los autores a comprender los criterios de éxito y aplicar mejor las técnicas.

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.

Un ejemplo de cómo obtener un objeto Guideline de una lista de reglas:

// 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 clase Criterion describe los criterios de éxito WCAG 2.0, heredados de la clase abstracta Rule. Puede encontrar información detallada aquí: Understanding Techniques for WCAG Success Criteria. La base para determinar la conformidad con las WCAG 2.0 son los criterios de éxito del estándar WCAG 2.0, no las técnicas.

Se proporcionan criterios de éxito verificables para cada recomendación, de modo que las WCAG 2.0 puedan aplicarse en áreas donde se requieren pruebas de cumplimiento.

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.

El criterio contiene una lista de techniques para cumplir con las pautas de accesibilidad del contenido web WCAG. Si todos los métodos suficientes para un criterio determinado están respaldados por la accesibilidad, entonces el criterio de éxito ha pasado.

Utilice el método GetCriterion() para acceder a los criterios de la guía:

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

Verifique HTML con reglas específicas de accesibilidad 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());
}

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.

Ver también

• El artículo Accesibilidad del Lector de Pantalla explica cómo diseñar un sitio web para la accesibilidad del lector de pantalla de acuerdo con las directrices WCAG mediante la API Aspose.HTML for .NET.
• Consulta el artículo Accesibilidad al contraste de color si quieres aprender a ajustar correctamente el contraste de tu contenido web según los estándares WCAG, la autoridad mundial en accesibilidad web. Descubrirás cómo probar la accesibilidad del contraste de color con C# y hacer que tu contenido web sea fácil de leer para todos los usuarios.
• En el artículo Validador de Accesibilidad, aprenderá sobre la clase AccessibilityValidator, que permite probar reglas de accesibilidad web, como principios, directrices y criterios.
• El artículo Errores y Advertencias analiza las clases e interfaces que ayudan a recopilar información sobre errores y advertencias durante las pruebas de accesibilidad web. Se centra en los criterios de fallo y los métodos que informan sobre errores, y proporciona un ejemplo en C# para recuperar errores de accesibilidad web tras probar un documento HTML.

Aspose.HTML ofrece un Comprobador de accesibilidad web gratuito en línea. Esta herramienta escanea páginas web, las valida para verificar su conformidad con WCAG, identifica problemas y sugiere mejoras. Obtenga información instantánea sobre el cumplimiento de su sitio web, lo que le permitirá determinar el alcance de las correcciones necesarias y la brecha entre el estado actual de su sitio web o documento HTML y los requisitos WCAG.