boolean guard question about guard

[safakgur]

Hi, I'm glad you liked the library.

Guard.Argument overloads expect the value and name of a single argument, and failed preconditions throw exceptions for that specific argument. The reason why () => myStuff || myOtherStuff doesn't work is that it does not represent a single argument.

var a = 1;
var b = 2;

// The following lambda expression is a MemberExpression that represents the variable "a".
// Guard.Argument compiles that expression to get the value, 1.
Guard.Argument(() => a);

// The following lambda expression is a BinaryExpression that adds "a" and "b".
// It doesn't represent a single parameter which Guard can get the value and name of.
Guard.Argument(() => a + b);

If your method accept multiple arguments, you need to have a Guard.Argument(...) call for each. This allows the ParamName and Message properties of the exceptions thrown to be unique per argument.

If you're sure that you want to threat a combination of arguments as a single argument, you can use the Guard.Argument overload that accepts the argument value and name as separate parameters.

void Foo(bool a, bool b)
{
    // Here we specify a combination of values, and a custom name
    // to be included in exception messages.
    Guard.Argument(a || b, "a or b").True();
}

Update: However, I would recommend this approach instead:

void Foo(bool a, bool b)
{
    // Here, both a and b can be false if the other one is not.
    // Since "a" is the first argument, we'll blame "b" if it's not consistent with "a".
    if (!a)
        Guard.Argument(() => b).True("b can only false when a is true.");
}

I hope this helps, please let me know if you have any more questions.

[eiredrake]

ah so the 'e' in question that it's complaining about is the name of the argument? Yep that helps. The check was to make sure a particular JSON fragment had one of two options in it or not. A sanity check basically. I appreciate the help!

[safakgur]

Kind of.

e is the lambda expression you specify. It's body is a MemberExpression when you write it like () => foo. A member expression has a name we can use (foo). We can also compile the expression to get its value, so we can have both the name and value of the argument - it's just for convenience over the overload that accepts the name and value separately.

But when you write e like () => foo || bar, it's body becomes a BinaryExpression. Now it's the logical OR result of two different member expressions. We can still compile it and get a value but we now don't have a name, because the expression doesn't point to a single named argument.

Is the JSON fragment a Newtonsoft JObject that you accept as a parameter? Maybe you can use member guards to validate it. But I guess writing a "JSON to model" parser function and using Guard.Wrap with it would make more sense. Though you'd have to throw exceptions manually for invalid JSON values in that function.

I hope this clarifies things.