Q:

Is there a way to detect the exception in dispose? 

I have the following scenario:
class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (new Foo())
            {
                throw new Exception("Inside using block");
            }
        }
        catch (Exception e)
        {

        }
    }
}

public class Foo : IDisposable
{
    public void Dispose()
    {
        throw new Exception("Inside dispose");
    }
}

Is it somehow possible, to get the thrown exception - "Inside using block" - in the Dispose method of Foo and make it an InnerException of the Exception Inside dispose? 
Edit:
For example:
class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (var fi = new FileHandler())
            {
                //open the file
                fi. Open();

                //write to the file
                fi. Write();

                //excption occurs
                throw new Exception("Inside using block");

                fi. Close();
            }
        }
        catch (Exception e)
        {
            //now I only have the exception from the dispose but not the exception that occured in the using block itself
            //I know I could wrap the code inside the using in a try/catch itself, just asking if it is possible without 2 try/catches
        }
    }
}

public class FileHandler : IDisposable
{
    public void Dispose()
    {
        //Close the file
        //for some reason it fails with an exception
        throw new Exception("Inside dispose");
    }
}

A:

Per the Framework Design Guidelines (Cwalina, Abrams), section 9.3:

AVOID throwing an exception from within Dispose(bool) except under critical situations where the containing process has been corrupted. 
If Dispose could raise an exception, further finally block cleanup logic will not execute.  To work around this, the user would need to wrap every call to Dispose (within their finally block!)  in a try block, which leads to very complex cleanup handlers.  If executing a Dispose(bool) method, never throw an exception if disposing is false. 

Also from section 9.3:

AVOID making types finalizable.  Carefully consider any case in which you think a finalizer is needed.  There is a real cost associated with instances with finalizers, from both a performance and code complexity standpoint."