Hi,
which code of the following is more optimized, or is there a better way?

public void SomeFunction()
{
   if(true)
   {
       //do something
       return;
   }
   else
   {
       return; //the meaning of exit when false
   }
}

or this way :

public void SomeFunction()
{
   if(!true)
   {
      return;
   }
   //do something
   return;
}

It doesn't matter. The check for true or false still has to be made one time.

But obviously, this may be a little faster: Since true is always true, there's no need to check ;)

But I guess that wasn't want you wanted to hear.... ;)

Imar
---------------------------------------
Imar Spaanjaars
Everyone is unique, except for me.
Author of ASP.NET 2.0 Instant Results and Beginning Dreamweaver MX / MX 2004
Want to be my colleague? Then check out this post.

come on ma friend what i mean that is not a real code case,
true means if the conditions become true.

I know that; that's why I added a smiley.

However, the first part of my reply still holds true: it doesn't matter wether you check for true or false in this case. In both cases, a simple if check has to be made. Either something is true, or false, and your code acts accordingly. In the example you posted, there isn't anything to optimize.

I think it's more a matter of preference; some people like the second example because it doesn't give you lots of nested if statements.

Imar
---------------------------------------
Imar Spaanjaars
Everyone is unique, except for me.

thnx ma friend,
you know what i like the second style of the code too, i have many questions like this on code styles and optimizations, such example like the SqlConnection Close() issue, many sites talk about this, some of them
recommend to use "using {... }" block for critical code, some close it in "Finally{... }" section ,
i know i talk toooo much :( but in short what do u suggest me to read or to navigate on the internet for
programming performance tips??

In that particualr instance, using versus finally, there is no difference. The compiler replaces the using block by the appropriate finally block, and adds the call to Dipose as well. That's why the using part will not compile if the class you try to instantiate does not implement IDisposable. The MSIL generated at the end is the same.
As a matter of style the using is less verbose and quicker so I always prefer it.

--

Joe (Microsoft MVP - XML)