As a dev validating a recursive object graph, I would like the validator to support recursion

[craigfowler]

As a developer writing validation, I would like to be able to recursively apply validation logic to my object model, when a validated value is of a type for which I have already configured sufficient validation.

An example of this kind of validation would be for validating something like a DOM or document format constructed from nodes. In (for example) an HTML DOM, an "Element" node may have child nodes which are themselves "Element" nodes. This may continue to an almost-unlimited degree.

The meaning of recursive validation

The work performed in this ticket needs to deal with both of the scenarios described below.

Primary meaning of recursive validation: "I already know how to validate this type"

At present, the validation framework has no way to express "Validate this value in the same way as a value for which validation was already configured". So, I would need to write new ManifestValue instances for each level of recursion, ad infinitum. This ticket is about supporting that form of recursion, where I say "Validate object of type X in this manner, and if that X contains an object of type Y, which may contain further (different) instances of X, then validate those in the same way as I would have validated the original X".

Another meaning of recursive validation: Circular references

Recursion can have another meaning though, and that is dealing with actual circular references in the validated object model. This is different from the above in that we are dealing with "This object of type X contains an object of type Y, which contains the exact same instance of type X as we already validated". In that scenario we must break the loop of recursion, because otherwise we would create an endless validation loop.

[craigfowler]

Dev approach idea

Validating descendants of the same type

Dealing with the first recursive validation scenario is quite easy. Simply use a circular reference to a previously-used ManifestValue. So one of the ManifestValueBase.Children would be an instance of ManifestValue which has already been configured as part of the overall manifest.

Validating circular references

To validate actual circular references, I think I will need to implement by skipping the validation of any validated values within the validation hierarchy when any of their parent values is a reference to the same object instance. So, when adding any new validated value, if the value is a reference type then move through each of that value's parent validated values. If any of them is a reference to the same object instance with the same validation manifest then skip the current validated value and do not validate it. If the validated value is the same but has a different manifest then it is OK to validate it. Of course, if it is seen again then do not validate it if it is associated with either manifests which were seen already.

Effectively the parent validated values (and the associated manifests) become a form of closed list for the creation of validated values. If a combination of reference & manifest has been seen before then we don't validate it again.

[craigfowler]

There's a problem with the dev approach above. There are a few members of a ManifestValue which should not be taken from the recursive value. These indicate:

• The member name
• The accessor function
• The parent value

Because these need to be distinct for a recursive value, we cannot just reference the original value.