Hi group,

I am quite new to exceptions in .NET and I am a bit confused of how to
use the inner exceptions. Could anyone explain? Let's say I have a
function that takes a double (X) that is not supposed to be less or
equal to zero. Let's call this function DoSomething.

Also let's say that this function in turn calls another function doing
something with X.

Then if there is a bug in the DoSomething function that causes the
other function to throw an ArgumentOutOfRangeException.

void DoSomething(double X)
{
    if(X<=0)
       throw new ArgumentOutOfRangeException("X","X has to be greater
than zero");
    X-=10;   // This is a bug..
    AnotherFunction(X);
}

void AnotherFunction(double X)
{
    if(X<=0)
       throw new ArgumentOutOfRangeException("X"," X has to be
greater than zero ");
    .
    .
    // Do something with X
}

Ok, now if I call DoSomething with 10 or less I will get an
ArgumentOutOfRangeException. Then I will think that this is because I
called DoSomething with a value of X less or equal to zero.

try
{
  double x= getValueFromUser();
  DoSomething(X);
}
catch(ArgumentOutOfRangeException e)
{
  MessageBox.Show("Dear User, please enter a value greater than 0");
}

But the problem here was not the input from the user but the bug in
DoSomething...

So what is the correct use of exceptions/innerexceptions? Should I
instead change the DoSomething to catch exceptions and rethrow them as
inner exceptions in an own exception type? Like this?

void DoSomething(double X)
{
    if(X<=0)
       throw new ArgumentOutOfRangeException("X","X is to small");
    X-=10;   // This is a bug..
    try
    {
       AnotherFunction(X);
    }
    catch(ArgumentOutOfRangeException e)
    {
       MyOwnException myex = new MyOwnException("Call to
       AnotherFunction failed",e);  // Set innerexception as e
    }
}

or should I catch all exceptions that AnotherFunction could throw
(catch the exceptions base type) and rethrow them as my own exception
with the innerexception set to the original exception?

Does this mean that in all assemblies that I write, in all public
functions, I should catch all exceptions and rethrow them as my own
exceptions with the innerexceptions set to the original exception? Or
have I missed something here, is there another approach to avoid the
problem above?

Any help to make me see this clearer is highly appreciated.

/kenny