Accessibility Validator – Überprüfung der Zugänglichkeit von Websites gemäß WCAG

Validator erstellen

Aspose.HTML for .NET bietet den Aspose.Html.Accessibility Namespace, der für alle Manipulationen und Überprüfungen im Zusammenhang mit der Barrierefreiheit im Web zuständig ist. Die Klasse AccessibilityValidator initialisiert ein Objekt, das verwendet wird, um das Dokument gegen die WCAG-Erfolgskriterien zu validieren. Die Klasse hat keinen internen Konstruktor, daher können Benutzer nicht direkt ein Objekt der Klasse erstellen. Um ein Objekt zu erstellen, müssen Sie den Container WebAccessibility verwenden.

Um einen Validator zu erstellen, initialisieren Sie das Objekt der Klasse WebAccessibility wie folgt:

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

Das Objekt webAccessibility verfügt über die folgenden grundlegenden Methoden zur Erstellung eines Validators:

Methods	Description
CreateValidator()	An instance of AccessibilityValidator is created according to all the rules with a ValidationBuilder.All object.
CreateValidator(Action<ValidationBuilder> builder)	An instance of AccessibilityValidator is created according to all the rules, where the builder is a lambda expression with a list of methods-settings.
CreateValidator(ValidationBuilder builder)	An instance of AccessibilityValidator is created according to all the rules with a ValidationBuilder object.
CreateValidator(IRule rule)	A new AccessibilityValidator instance is created for a specific rule, given the full parameters of the ValidationBuilder.All object.
CreateValidator(IRule rule, Action<ValidationBuilder> builder)	Initializes a new instance of the AccessibilityValidator that contains a rule that matches the builder’s settings, where the builder is a lambda expression with a list of methods-settings.
CreateValidator(IRule rule, ValidationBuilder builder)	Initializes a new instance of the AccessibilityValidator that contains a rule that matches the builder’s settings. The builder instance is a static instance of the class ValidationBuilder.
CreateValidator(IList<IRule> rules)	An AccessibilityValidator instance is created for a specific rules list.
CreateValidator(IList<IRule> rules, ValidationBuilder builder)	An AccessibilityValidator instance is created for a specific list of rules based on the settings of the ValidationBuilder object.
CreateValidator(IList<IRule> rules, Action<ValidationBuilder> builder)	An AccessibilityValidator instance is created for a specific list of rules where the builder is a lambda expression with a list of settings ValidationBuilder.

Im Folgenden werden Beispiele für die Initialisierung eines AccessibilityValidator-Objekts aufgeführt. Der erste Validator (validator) ist eine umfassende Instanz, die mit ValidationBuilder.All erstellt wird und alle Regeln aus dem Repository anwendet. Ein bestimmtes Prinzip wird mit Hilfe seines Codes abgerufen, und ein zweiter Validator (validatorRule) wird für die mit diesem Prinzip verbundenen Regeln erstellt, wobei dieselben umfassenden Einstellungen beibehalten werden. Schließlich wird ein dritter Validator (validatorCSS) mit Hilfe eines Lambda-Ausdrucks eingerichtet, um die Validierungskriterien zu verfeinern, wobei alle Ebenen berücksichtigt werden und CSS-basierte Regeln einbezogen werden. Dieser Ansatz bietet Flexibilität bei der Anpassung von Validatoren für spezifische Zugänglichkeitsprüfungen und ermöglicht gezielte Validierungsstrategien.

	// Initialize a webAccessibility container
    var webAccessibility = new WebAccessibility();
    
	// Create an accessibility validator with a static instance for all rules from repository that match the builder settings
    var validator = webAccessibility.CreateValidator(ValidationBuilder.All);
	
    // Get a principle by code
    IRule rule = webAccessibility.Rules.GetPrinciple("1");

    // Create an accessibility validator for one principle, whose rules match the instance settings ValidationBuilder.All
    var validatorRule = webAccessibility.CreateValidator(rule, ValidationBuilder.All);

    // Create an accessibility validator with lambda-expression settings for all rules from repository that match the builder settings inside a project
    var validatorCSS = new AccessibilityValidator(builder => builder.AllLevels().UseCSS());

ValidationBuilder-Klasse

Die Klasse ValidationBuilder definiert eine Hilfsklasse, die verwendet werden kann, um die Liste der vom Validator zu prüfenden Regeln anzupassen. Der ValidationBuilder definiert Methoden und bietet konkrete Implementierungen der Konfigurationsschritte.

Method/Property	Description
ValidationBuilder.None	None of the parameter settings are specified, it is convenient for creating a filter from scratch, when you need to specify which levels, technologies, etc. should be used when checking.
ValidationBuilder.Default	Rules for General technologies, Failures for all levels of criteria will be used when checking the document.
ValidationBuilder.All	The verification will take place at all levels of criteria, for all technologies, including HTML,CSS,Crtipt.
SetHTMLTags(params string[] tags)	The user can specify a list of html-tags to be checked in the document.
AllTechnologies()	All technologies will be applied when checking the document.
UseHTML()	The method indicates that elements of the HTML technology will be checked in the document.
UseCSS()	The method indicates that elements of the CSS technology will be checked in the document.
UseScript()	The method indicates that elements of the ClientSide-Script technology will be checked in the document.
UseFailures()	The method indicates that failures rules will be checked in the document.
UseGeneral()	The method indicates that general rules will be checked in the document.
AllLevels()	The method sets all criteria levels and indicates that the document will be checked according to the criteria of all three levels.
UseLowestLevel()	The method determines that the document must be validated against low-level criteria.
UseMiddleLevel()	The method determines that the document must be validated against mid-level criteria.
UseHighestLevel()	The method determines that the document must be validated against high-level criteria.

Der folgende Codeausschnitt ist ein Beispiel für die Erstellung des Builders und seine Übergabe als Parameter an den Validator:

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

    // Create an accessibility validator with object All
    var validator = webAccessibility.CreateValidator(ValidationBuilder.All);

    // Create an accessibility validator with empty filters, and set's html and css technologies, low and middle levels
    var validatorHTML = webAccessibility.CreateValidator(ValidationBuilder.None.UseHTML()
                                                                               .UseCSS()
                                                                               .UseLowestLevel()
                                                                               .UseMiddleLevel());

    // Create an accessibility validator with lambda-expression for all levels and only CSS technologies
    var validatorCSS = webAccessibility.CreateValidator(builder => builder.AllLevels().UseCSS());

    // Create an accessibility validator for all levels of criterion and only img and input elements will be checking
    var validatorIMG = webAccessibility.CreateValidator(builder => builder.AllLevels()
										.AllTechnologies()
                                        .SetHTMLTags("img", "input"));

ValidationResult Klasse

Die Klasse ValidationResult ist die zentrale Komponente der Validierung der Barrierefreiheit im Web. Sie kapselt die Ergebnisse von Zugänglichkeitsprüfungen und bietet eine strukturierte Möglichkeit, die Ergebnisse von Validierungsoperationen zu analysieren, zu verwalten und darauf zu reagieren. Um es zu verwenden, instanziieren Sie ein Validator-Objekt und rufen die Methode Validate(document) auf, wobei Sie das zu prüfende Dokument übergeben. Die Methode gibt ein ValidationResult Objekt zurück, das die Ergebnisse des Validierungsprozesses enthält.

Wichtige Eigenschaften:

Property	Description
Success	Returns a boolean that says whether the validation succeeded.
Details	Returns Collection of RuleValidationResult objects containing details about any validation results.

Dokument validieren

Um die Dokumentenvalidierung durchzuführen, müssen Sie die folgenden Schritte ausführen:

1. Verwenden Sie den Konstruktor WebAccessibility(), um eine Instanz der Klasse WebAccessibility zu erstellen, die für die Überprüfung der Barrierefreiheit im Web zuständig ist.
2. Rufen Sie die Methode CreateValidator() auf, um ein validator-Objekt zu erstellen.
3. Laden Sie ein HTML-Dokument mit einem der HTMLDocument() Konstruktoren.
4. Verwenden Sie die Methode Validate(document), um das Dokument anhand der Regeln für die Barrierefreiheit zu validieren.
5. Das Ergebnis der Validierung ist eine Instanz der Klasse ValidationResult.
6. Drucken Sie die Validierungsergebnisse auf der Konsole aus und verwenden Sie sie bei Bedarf für weitere Analysen.

Hier ist ein Beispiel für den Aufruf einer Dokumentüberprüfung. Der folgende Code schreibt in die Konsole, welche der Regeln den Test bestanden haben und welche nicht:

// Validate HTML against WCAG rules using C#

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

// Create an accessibillity validator with static instance for all rules from repository that match the builder settings
AccessibilityValidator validator = webAccessibility.CreateValidator(ValidationBuilder.All);

// Prepare a path to a source HTML file
string documentPath = Path.Combine(DataDir, "input.html");

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

    // Checking for success
    if (!validationResult.Success)
    {
        // Get a list of RuleValidationResult Details
        foreach (RuleValidationResult detail in validationResult.Details)
        {
            Console.WriteLine("{0}:{1} = {2}", detail.Rule.Code, detail.Rule.Description, detail.Success);
        }
    }
}

Eine ausführlichere Beschreibung finden Sie in dem Artikel Validierungsergebnisse – Überprüfung der Barrierefreiheit in C#.

Siehe auch

• Im Kapitel Zugänglichkeitsprüfung erfahren Sie, wie Sie die Zugänglichkeit einer Website auf die Einhaltung der WCAG überprüfen oder nur bestimmte Kriterien erfüllen können, indem Sie Klassen und Methoden der Namespaces Aspose.Html.Accessibility und Aspose.Html.Accessibility.Results verwenden.
• Der Artikel Screen Reader Accessibility erklärt, wie man eine Website für die Zugänglichkeit von Bildschirmlesegeräten gemäß den WCAG-Richtlinien unter Verwendung der Aspose.HTML for .NET API gestaltet.
• Schauen Sie sich den Artikel Farbkontrast in C# prüfen an, wenn Sie erfahren möchten, wie Sie den Kontrast Ihrer Webinhalte richtig an die WCAG-Standards, die weltweite Autorität für Barrierefreiheit im Web, anpassen. Sie erfahren, wie Sie die Zugänglichkeit von Farbkontrasten mit C# testen und Ihre Webinhalte für alle Benutzer leicht lesbar machen können.
• In dem Artikel Web-Zugänglichkeitsregeln erfahren Sie, wie Sie die Klasse AccessibilityRules, eine Sammlung von WCAG-2-Anforderungen, Erfolgskriterien und Techniken, für Prüfungen der Barrierefreiheit im Web verwenden können.
• Der Artikel Fehler und Warnungen behandelt die Klassen und Schnittstellen, mit deren Hilfe Informationen über Fehler und Warnungen während des Testens der Barrierefreiheit von Websites gesammelt werden können. Er konzentriert sich auf die Fehlerkriterien und Methoden, die Fehler melden, und bietet ein C#-Beispiel zum Abrufen von Fehlern bei der Barrierefreiheit nach dem Testen eines HTML-Dokuments.

Aspose.HTML bietet einen kostenlosen Online- Web-Zugänglichkeits-Checker. Dieses Tool scannt Webseiten, prüft sie auf WCAG-Konformität, identifiziert Probleme und schlägt Verbesserungen vor. Sie erhalten sofortige Einblicke in die Konformität Ihrer Website und können so den Umfang der notwendigen Korrekturen und die Lücke zwischen dem aktuellen Zustand Ihrer Website oder Ihres HTML-Dokuments und den WCAG-Anforderungen bestimmen.