Basic C# question if - else

I was wondering if someone could tell me if this sample is correct please. Please ignore the if statement i wrote it for demonstration purposes only.

basically what I want to know is, if I need to throw an exception in my else, is it right to have it return false then thrown an exception, like follows:

public bool test(Int j)
{
    if(!TestOnJThatcanThrowOutOfMemoryException开发者_Go百科 E)
    {
        return true;
    }
    else
    {
        return false;
        throw new OutOfMemoryException();
    }
}

OR - should I throw exception then return false outside else statement like this:

public bool test(Int j)
{
    if(!TestOnJThatcanThrowOutOfMemoryException E)
    {
        return true;
    }
    else
    {
        throw new OutOfMemoryException();
    }
    return false;
}

Either of the following would make sense:

a) return the result of the test, don't throw:

    public bool test(Int j)
    {
        if(!TestOnJThatcanThrowOutOfMemoryException(j))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

(Note that this example is overly verbose, and can be rewritten as:)

    public bool test(Int j)
    {
        return !TestOnJThatcanThrowOutOfMemoryException(j)
    }

b) throw if the test fails, do nothing otherwise:

    public void test(Int j)
    {
        if(TestOnJThatcanThrowOutOfMemoryException(j))
        {
            throw new OutOfMemoryException();
        }
    }

In other words, make up your mind what that method is supposed to do - execute the test and return the result as a boolean value, or execute the test and throw when it fails.

When an exception occurs it does not execute the rest of the code in the method. When a return statement is used it breaks the execution of the current method.

So you only need to call one of the two

i.e.

public bool test(Int j)        
{            
     if(!TestOnJThatcanThrowOutOfMemoryException E)            
     {    
          return true;            
     }            
     else            
     {                
         throw new OutOfMemoryException();            
     }        
}

If you return false and then throw an exception than the exception will not be thrown. the method exits at the return statement.

if you throw an exception and then return false, then the exception will be thrown and caught in the appropriate catch block and your final return false will not execute.

So, if you want to throw an exception here, then throw the exception. If you want to return false here, return false.

In both cases, as is, only the first of the two will execute. Both return and throw cause execution to leave the function, so neither is technically correct.

In the first case, it will return, and the throw will never be called. In the second, the opposite is true (for the else block).

If you want an exception, throw it. Don't bother putting a return false anywhere.

The first example will never throw the exception as the return false ends the logic flow.

The second example the "return false;" will never be hit as either the return true; statement will be executed or the exception will be thrown.

In both of your examples you are doing something wrong. What do you want to achive?

In the first example throw statement will never be executed and in the second one return false won't be executed.

If you throw, the return statement won't get executed. All you need is:

public bool test(Int j)        
{            
   if(!TestOnJThatcanThrowOutOfMemoryException E)            
   {                
      return true;            
   }            
   throw new OutOfMemoryException();            
}

Your second option (just throwing the exception in the else) would be more correct. Note, though, that there is no code path to reach the return false; statement -- either the if is true, in which case true is returned, or its not, in which case an exception in thrown (thus aborting the code to the next-higher-level handler). So you don't really need it.

It appears that your attempt appears testing the value that comes to argument "int j". The checking should fit in with a try catch,

try
{
   // take a object as argument and try parse it to an int here 
   // or a TryParse will return a true/false if bool can return without exception.
   int something = int.Parse(j);
}
catch (TestOnJThatcanThrowOutOfMemoryException e)
{
   return true;
}
catch (OutOfMemoryException e)
{
    // this will be hit if it isn't a TestOnJ.. exception
    return false;
}
catch 
{
    // and here if not any of above
    return false;
}

Though, i'm not sure if I ever would create a method which purpose would be just to force a specific kind of exception. Sorry if missunderstand you completely,

Go for the second option, but remove the "return false" statement at the end. Your method returns a boolean, so in case of an OutOfMemoryException (second if statement in your case), your method will not get a chance to pass a return value of false. But then this wont be an issue, if you handle the return value appropriately in the code which calls your method. A boolean is implicitly initialized to false, so in your calling function check if this method returned a true before you execute the remaining code.