JustDummies

Le composeur ne lit jamais le paramètre auquel l’un des opérandes est lié : cet opérande est donc tiré puis jeté.

Combine génère chaque partie avant d’appeler le composeur — contraintes construites, vérifications de conflit exécutées, valeur produite — puis la laisse tomber. Rien n’échoue : la valeur composée est bien formée, et ne porte simplement pas la partie que le site d’appel dit qu’elle porte.

Non conforme

IAny<Customer> customer = Any.Combine(
    Any.String().NonEmpty().WithMaxLength(50),
    Any.String().StartingWith("ORD-").WithLength(12),
    (name, reference) => new Customer(name));      // JD027 : 'reference' n'atteint jamais le Customer

Conforme

IAny<Customer> customer = Any.Combine(
    Any.String().NonEmpty().WithMaxLength(50),
    Any.String().StartingWith("ORD-").WithLength(12),
    (name, reference) => new Customer(name, OrderReference.Create(reference)));

Ou supprimer l’opérande, s’il ne fait réellement pas partie de la valeur :

IAny<Customer> customer = Any.String().NonEmpty().WithMaxLength(50).As(name => new Customer(name));

Dire que le tirage est délibéré

Nommer le paramètre _, comme C# l’écrit partout ailleurs pour dire « je sais, et c’est voulu » :

Any.Combine(first, second, (value, _) => new Wrapper(value))   // aucun diagnostic

Pourquoi cela arrive

Les deux formes les plus fréquentes sont un argument de constructeur oublié pendant un remaniement, et un composeur dont les paramètres ne correspondent plus à ses opérandes après l’insertion d’un opérande au milieu. Les deux laissent un générateur dont les contraintes soigneusement écrites n’ont d’effet sur rien de ce que le test observe.

Ce qui n’est pas signalé

• Un paramètre nommé _.
• Un composeur passé comme groupe de méthodes — son corps n’appartient pas nécessairement à cette compilation, donc les opérandes qu’il utilise ne sont pas connaissables.
• Un composeur dont le corps entier est un throw. Il ne lit aucun paramètre par construction, et exerce le chemin d’échec que Combine enveloppe plutôt qu’il n’ignore un opérande.
• Un paramètre lu seulement dans un lambda imbriqué : cela compte comme lu.