C# Feature request - the .! operator

All too often I find myself writing if clauses with negative logic - rather than checking for a true condition, I check for false:

if (!myDictionary.Contains(key))
{ } 

This syntax, while very common, isn't really easy to parse. While I can express my required logic in words as "if my dictionary does not contain key", my syntax reads like the unintuitive "if not my dictionary does contains key" - I tend to think of my C# code in terms of natural languages. Usually English, even though it's not my native tongue.

So in order to bring C# more in line with my way of thought, I thought of having C# accept this sort of syntax:

if (myDictionary.!Contains(key))
{ } 

The .! operator is valid only before a boolean member, and inverts the return value, making it equivalent to the code above. Now the code reads the way it should and is just as easy to understand.

How does this sound? Any other supporters for this? Should I file a feature request on Connect?

(Originally posted on my blog, but I wanted Niner opinions too)

no no no no

then we would have yet another way to express that intention:

if (!f.Contains())

if (f.!Contains())

if (f.Contains() == false)

I use the last case myself... probably just because it's clearer than the 1st case.

Minh wrote:

no no no no
if (f.Contains() == false)

if (false == f.Contains())

Now that's the way to do it

Rotem

I'm guessing that while it might be easier for you to read, it would cause more over-head in the compiler that it's worth.

Since it is your dictionary you can do whatever you want.
You named it myDictionary so why not add a method called doesNotContain.

But yes since a lot of what we are doing is working with other peoples code, like frameworks etc. It would be nice if there were easier to use and read.

I see what your saying, but don't feel it is clearer and only adds more "noise" to the language (which they/we don't need). Test for false or use the ! (not) or refactor the code.

if ( myDictionary.Contains(key) )
   //Do something.
else
   throw new Exception("not exist."); 

Yuk.    
I can't stand having an operator embedded in an object reference.  

That's horrible!  That's !readable!

No. That's just not how C-style languages work.

"Foo foo; foo.bar()" i C# means invoke method bar of Foo on the foo instance.

Likewise, !foo.bar() means negate the return of invoking method bar of Foo on the foo instance.

C-style languages in many ways read right-to-left, and that's just the nature of it.

The programming language is not a natural language - you have to remember that. The more programming language is simple for the people, the more difficult and error-prone for computers/compilers.

If there is the "not" operator (!), why adding more?

Sometimes it could not be even simpler; consider this:

if (!collection.!Contains(key))
{
  // do something
}

Is it simpler for you?  And I don't think people wouldn't use such expression - if they can, they certainly will.

Cheers!

I think the way it is is better than what you suggested.

It has its bases in logic. the ! acts as the negation of a statement. That is understood universaly. You negate something. So you say if the negation of the existance of my key in my dictionary evaluates to true then enter the if block.

So I like it the way it is.

I wouldn't support modifying the language for that... particularly as I happen to like using   if (!something.value)

The attraction of C# is it's terse syntax... as opposed to VB.

Couldn't you simply write negative "overloads" of your functions ?


e.g  Something.Contains(foo)

       Something.NotContains(foo)


Where the second is a reverse return of the first...

e.g. return (!Something.Contains(foo));


of course... where we run into trouble is with natural language concepts like...

      Something.MaybeContains(foo)  

Rotem Kirshenbaum wrote:



if (false == f.Contains())

Ick.

While there is a good reason for doing it in C/C++ there is no good reason for doing it in C# because the assignment operator isn't valid there and it's much less readable.

Please:

this.Thread >& /Dev/Null

to mix a bit of Cshell with C#

or:  please send this thread to ..... 

AndyC wrote:



Rotem Kirshenbaum wrote:  if (false == f.Contains())

Ick.

While there is a good reason for doing it in C/C++ there is no good reason for doing it in C# because the assignment operator isn't valid there and it's much less readable.

That's a comparison operator, Andy!   !Assignment!

I've never put the true or false first, for readability's sake I guess...