Correct way to pass errors back to the calling code

Question

I have a function called connect like so:

public boolean connnect(){
{
 ..... connecting codde
 if(connectionSuccessfull)
 {
   return true;
 }
  else
 {
   return false;
 }
}

This is a very basic form of error handling, I want to upgrade this function to handle errors correctly. Such as not just tell me false there was an error, but be able to say, error, Authentication failed, or Time-out error etc. This information then needs to be sent back up the line to the Caller so it can know what happened.

What is the correct way to go about doing this?

{EDIT} In my care its quite probable that an exception will occur I would say 50% of the time.

I have come up with this, does it look partially correct?

namespace MobileWebServices.Exceptions
{
    //Timeout
public abstract class TimeOutException : Exception
{

}

public class ConnectingTimeOutException : TimeoutException
{
}

public class DissconnectingTimeOutException : TimeoutException
{

}

//Authetntication
public abstract class AuthenticationException : Exception
{

}
public class BadAuthenticationException : AuthenticationException
{

}
}

Answer 1

Something along the lines of:

public void Connect()
{
  try
  {
    //code here to look-up the connection details
    if(!ValidateConnectionDetails(details))
      throw new InvalidOperationException("The connection details are not valid.");
    //code here to establish the connection
    if(SomeTestThatShowsWereNotHappyWithTheConnection())
      throw new Exception("The connection is bad, for some reason");
  }
  catch(SocketException se)
  {
    //We'd only have this block if a socket exception is possible. We might just allow it to pass on up.
      throw; // User now gets the exception we got, exactly.
    //We might re-throw the error, but from here so the stack-trace goes to here rather than the innards of this method:
      throw se;
    //Most usefully we might throw a new exception that contains this as an inner exception:
      throw new Exception("Connecting failed", se);
    //Or even better, we might throw a more well-defined exception, that relates to this operation more specifically, with or without the inner exception, depending on whether that is likely to be useful:
      throw new ConnectionException("Some message, or maybe just a default is defined in the constructor");
    //OR:
      throw new ConnectionException("Some message, or maybe just a default is defined in the constructor", se);
  }
  catch(Exception ex)
  {
    //If we get to an exception ourselves that isn't of a particular type we're expecting, we probably shouldn't catch it at all. We might though want to note the exception before re-throwing it, or throw a more specific connection with this as an inner-exception:
    Log(ex);
    throw;
  }
}

Because you're no longer returning a value to indicate success, you could also now return an object that represents the connection you created:

public ConnectionObject Connect()
{
   // Much as above, but returning the object before the end of the `try`.
}

Returning values representing failure should only be done if that failure is both likely to happen, and something you expect the calling code to be able to reasonably react to right at the point of calling. This isn't that likely with code to connect since the calling code could be code that e.g. connects and then does an operation, and the code calling that in turn is where the exception (whether from here or the subsequent operation) should be caught - it's the code that ultimately cares about the failing.

In the latter case, then returning a value indicating the failure makes a lot more sense. Here though, I'd probably still consider an exception, because it can encapsulate more information, be used by coders in the normal way they use other .NET methods, and because the calling code is probably not written thinking "try to get the connection and then if it works..." it's written thinking "get the connection and then..." with the error case being exactly that; an error case. (For comparison, a method like int.TryParse() is to answer the question "does this string represent an integer, and if so what is it?" where the method int.Parse() answers the question "what is the integer in this string?" with there not being an integer being an error condition).

To think of it another way. Are you currently using a web-browser to browse the web, or are you using it to try to browse the web? Your internet connection could die on you, stopping you from continuing to read these answers, but you'd consider that a problem in what you were trying to do.

Answer 2

Here is a sample on how things should be done :
First use your connect() method to return an object (like a Socket for example).
Return a null one if it fails connecting without throwing an Exception.
In your connect() method try/catch your connecting instructions, and rethrow those catched.
Then in the calling method, catch all the Exceptions that can be thrown, and check if the returned object is null or not.
Here is an example of code using Sockets :

public static Socket connect()
{
    Socket s = null;
    try
    {
        IPEndPoint iEP = new IPEndPoint("127.0.0.1", 8080);
        s = new Socket(iEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        s.Connect(iEP);
        if(!s.Connected)
        {
            return null;
        }
    }
    catch(Exception e)
    {
        throw e;// Rethrow the Exception to the caller
    }
    return s;
}

public static void Main(String[] args)
{
    Socket mySocket = null;
    try
    {
        mySocket = connect();
    }
    catch(SocketException e)
    {
        // TODO - Detailed error about a SocketException
        Console.Error.WriteLine("SocketException: " + e.Message + "(" + e.ErrorCode + ")");
    }
    catch(SecurityException e)
    {
        // TODO - Detailed error about a SecurityException
        Console.Error.WriteLine("SecurityException: " + e.Message);
    }
    catch(Exception e)
    {
        // TODO - Detailed error about those Exceptions :
        // ArgumentNullException, ObjectDisposedException and InvalidOperationException
        Console.Error.WriteLine(e.GetType() + ": " + e.Message);
    }

    if(mySocket == null)
    {
        // TODO - Error while initializing the Socket
        Console.Error.WriteLine("Error while initializing the Socket");
    }

    // TODO - Use your Socket here
}

Answer 3

I think the best way is using the try catch exception surrounding your call with the exception you want :

catch(TimeoutException ex)
{
//Do something
}
catch(SqlException ex)
{
//do something
}

//....

catch(Exception ex)
{
//do something
}

Make sure of the order of your catch ( the global Exception in last)

Answer 4

The normal approach is to throw an exception (perhaps of a user-defined type), and then to catch those exceptions at a higher level.

If for some reason you cannot use exceptions, you could instead write a wrapper class that encompassed an error message (which would be null if no error occurred) and the bool result (which would only be relevant if the error message is null).

However, I would recommend using exceptions. (The only issue might be whether or not you need to globalise the error message string in the exception, but the consensus is that you should not.)