Question

I am fully aware that what I am about to ask is not good practice… but:

Let’s say I have a class containing a function that I want to always return a value, but store any exceptions that might occur for later processing. Something Like:

public Exception _error { get; set; }

public bool IsValid()
{
    try
    {
        //do something here to cause exception                

        return true;
    }
    catch (Exception ex)
    {
        _error = ex;
        return false;
    }
}

Now that I have stored the exception, is it at all possible to throw the exception from an outside method while maintaining both the original stack trace and exception type?

throw _error; //lose stack trace

throw new Exception("", _error) //lose type

Thanks for looking or answering.

EDIT:

Thanks to some additional points, I realize that the below idea only takes away information and doesn’t really add or simplify the situation. Thanks again to everyone.

After pondering Pieter’s answer and comments, I’m now wondering if making a wrapper Exception class like the below could be a partial solution. This overrides as much of the exception as possible to make the New exception look like its innerexception, including the stacktrace.. dirty I know, but interesting:

public class ExceptionWrapper : Exception
{
    private Exception _innerException;

    public ExceptionWrapper(Exception ex) : base("", ex)
    {
        _innerException = ex;
        this.Source = ex.Source;
        this.HelpLink = ex.HelpLink;
    }

    public override string StackTrace
    {
        get
        {
            return _innerException.StackTrace;
        }
    }

    public override System.Collections.IDictionary Data
    {
        get
        {
            return _innerException.Data;
        }
    }

    public override string Message
    {
        get
        {
            return _innerException.Message;
        }
    }

    public new Exception InnerException
    {
        get
        {
            return _innerException.InnerException;
        }
    }
}

Answer 1

No, this is not possible.

However, you normally solve this is by wrapping the exception in a new exception:

throw new MyException("Wrapper", _error);

This does maintain the stack trace of _error, but you do get a new exception. Your solution in your second example is the correct way of handling these cases.