Comments on: Elegant Invariant Checking with C# 3

By: Andrew

Andrew — Fri, 01 Aug 2008 03:01:02 +0000

Stuart,

This is done by picking apart and inspecting the expression tree resulting from the lambda.

Cheers,

Andrew.

By: Stuart Clark

Stuart Clark — Fri, 01 Aug 2008 02:20:00 +0000

I like the idea its got me thinking. The question I have is:

Check.Argument(() => arg1.IsNotNull); // throws ArgumentNullException

How would you determine the argument name when constructing your ArgumentNullException.

Without that its the equivalent of your original code minus the string argument name.

Invariant.ArgumentNotNull(arg1);

By: Judah Himango

Judah Himango — Thu, 31 Jul 2008 16:53:07 +0000

Regarding your use of C# 3 syntax to get around the redundancy, I suggested something similar to the CuttingEdge.Conditions library:

http://www.codeproject.com/script/Forums/View.aspx?fid=1498290&msg=2640907

But the author said:

I’m sorry Judah,

but it’s even worse than you would expect. I just did some performance testing. I compared the following two lines:

a.Requires(”a”).IsNotNull();

compared to:

a.Requires(() => a).IsNotNull();

What’s the difference? Well, the first line actually doesn’t even allocate a string. It just uses a reference (a 32 bit number) to reference a string that is already allocated (and as long as that string isn’t used, there only the cost of copying an Int32 on the stack).

The second isn’t a simple delegate allocation. It actually allocates 7 new objects on the heap, makes at least 9 (non-inlinable) method calls and does some heavy reflection to build up the Expression (see for yourself with Reflector). And the worst part is that it doesn’t do this only once during initialization. No, it does this every time a call to Requires(() => a) is made.

I found that the second statement is actually over 200 times slower than the first. here
you can take a look at my test code.

By: Jason Bock

Jason Bock — Thu, 31 Jul 2008 16:04:58 +0000

Have you seen this?

http://www.cuttingedge.it/blogs/steven/pivot/entry.php?id=38#body

By: Raimon

Raimon — Thu, 31 Jul 2008 15:19:26 +0000

this code can be used in generating documentation.

Invariant.ArgumentNotNull(arg1, “arg1″); // throws ArgumentNullException
Invariant.ArgumentNotEmpty(arg2, “arg2″); // throws ArgumentOutOfRangeException

it’s cool

By: Dan Goldstein

Dan Goldstein — Thu, 31 Jul 2008 14:07:33 +0000

I’m not so sure I see a big improvement. Invariant.ArgumentIsNotNull has the advantage of having the requirement at the beginning, not polluting intellisense and not having an ugly parameterless lambda function. Your new method only saves the need to specify the name of the argument in addition to its value.

By: Poul Foged

Poul Foged — Thu, 31 Jul 2008 12:23:48 +0000

Whats wrong with:

Invariant.ArgumentNotNull(arg1);

Invariant.Argument(arg1).IsNotNull();

- reflection should help us reveal the parameters real name….

By: John Rusk

John Rusk — Thu, 31 Jul 2008 09:55:36 +0000

What about putting the magic method later in the fluent API, outside the expression, something like:

Check.That(()=> arg1).IsNotNull();

In that case there’d be no extension methods, but would be too many parentheses for my liking…

What about

Require.Value( () => arg1);

By: Sergey

Sergey — Thu, 31 Jul 2008 05:28:11 +0000

Cool!

Tought in boo it is much more simple :)

def DbC[[Required(extendee != null, "extendee must be not null")]extendee as object]:

PS
What about ensures?

By: Johnny Hall

Johnny Hall — Wed, 30 Jul 2008 12:35:48 +0000

I’m liking the look of this, although I haven’t been so concerned with the issue to evaluate it properly yet.

http://research.microsoft.com/SpecSharp/