RecursiveDataAnnotationsValidation 2.3.1

RecursiveDataAnnotationsValidation

Allows recursive validation of sub-objects in a class when using DataAnnotations validation (also known as Attribute Validation). The current version of .NET Core's attribute validation does not handle objects within objects (or collections of objects). Therefore it is necessary to add some glue code to recurse through the object graph.

Installation

.NET Core

$ dotnet add package RecursiveDataAnnotationsValidation

Package Manager

PM> Install-Package RecursiveDataAnnotationsValidation

Usage

Usage of the recursive validation is nearly identical to using the standard validator.

var validator = new RecursiveDataAnnotationValidator();
var validationResults = new List<ValidationResult>();
var result = validator.TryValidateObjectRecursive(sut, validationResults);

There are more examples in the example and test projects.

SkipRecursiveValidationAttribute

The [SkipRecursiveValidation] attribute can be used on properties where you do not want to recursively validate. An example of this can be seen in SkippedChildrenExample.cs.

Shared objects, cycles and computed properties

• Each object is validated once, even when several properties point to it. This also stops cycles, such as a child that points back to its parent.
• Objects are compared by reference. Two separate objects that are Equals to each other, such as records with the same values or entities with the same Id, are each validated.
• Public static properties are walked, as well as instance properties.
• A property that builds a new object on each read, such as public Money Zero => new Money(0), could make the walk go on forever. So when an object's type overrides Equals, and the object equals an object of the same type, a base type or a derived type on its own path from the root, the validator checks that object's own attributes but does not walk into its properties. An invalid object below it is not reached.
• For a type that does not override Equals, mark such a property with [SkipRecursiveValidation]. Otherwise the walk overflows the stack, which ends the process.
• Two records that reference each other can also overflow the stack. A record's generated Equals compares properties in declaration order, so it follows the reference forever if it reaches it before a property that differs. This happens when the records have equal values, or when the reference is declared first. On .NET Framework it always happens, because the framework's Validator calls the record's generated GetHashCode, which follows the reference too. Marking the reference with [SkipRecursiveValidation] avoids the walk, but not the GetHashCode call on .NET Framework. There, override GetHashCode so it does not include the reference.

Framework types that are not walked

The validator does not walk the properties that these framework types declare: Type and other MemberInfo types, Assembly, Module, delegates, Uri, and FileSystemInfo, which covers DirectoryInfo and FileInfo. Reading those properties throws or never ends, for example Uri.Segments on a relative Uri, and they carry no validation attributes.

An object of one of these types is still validated. Attributes on the property that holds it, such as [Required] on a Uri property, still run. A subclass of your own, such as a class derived from Uri, is validated too, and the properties it adds are walked.

Other framework types are walked, so your objects inside them are validated. Examples are tuples, KeyValuePair items of a dictionary, and collections.

Build Status

Nuget Page

https://www.nuget.org/packages/RecursiveDataAnnotationsValidation/

History and attribution

This package grew out of a need to recursively validate POCOs used for the .NET Core options pattern. It is based on the DataAnnotationsValidatorRecursive project by Mike Reust. After a lot of experimentation, I forked that project. My goals at the time were to make minor improvements, port it to .NET Standard, and experiment with GitHub Actions. The two projects have since evolved independently.

Mike Reust's original copyright is retained in the LICENSE.