Metodo Exception.GetBaseException (System)

' Example for the Exception.GetBaseException method.
Imports System
Imports Microsoft.VisualBasic

Namespace NDP_UE_VB

    ' Define two derived exceptions to demonstrate nested exceptions.
    Class SecondLevelException
        Inherits Exception
           
        Public Sub New( message As String, inner As Exception )
            MyBase.New( message, inner )
        End Sub ' New
    End Class ' SecondLevelException

    Class ThirdLevelException
        Inherits Exception
           
        Public Sub New( message As String, inner As Exception )
            MyBase.New( message, inner )
        End Sub ' New
    End Class ' ThirdLevelException

    Class NestedExceptions
       
        Public Shared Sub Main( )
            Console.WriteLine( _
                "This example of Exception.GetBaseException " & _
                "generates the following output." )
            Console.WriteLine( vbCrLf & _
                "The program forces a division by 0, then throws " & _
                "the exception " & vbCrLf & "twice more, using " & _
                "a different derived exception each time:" & vbCrLf )
              
            Try
                ' This sub calls another that forces a division by 0.
                Rethrow()

            Catch ex As Exception
                Dim current As Exception
                 
                Console.WriteLine( _
                    "Unwind the nested exceptions using the " & _
                    "InnerException property:" & vbCrLf )
                 
                ' This code unwinds the nested exceptions using the 
                ' InnerException property.
                current = ex
                While Not ( current Is Nothing )
                    Console.WriteLine( current.ToString( ) )
                    Console.WriteLine( )
                    current = current.InnerException
                End While
                 
                ' Display the innermost exception.
                Console.WriteLine( _
                    "Display the base exception using the " & _
                    "GetBaseException method:" & vbCrLf )
                Console.WriteLine( _
                    ex.GetBaseException( ).ToString( ) )
            End Try
        End Sub ' Main
           
        ' This sub catches the exception from the called sub
        ' DivideBy0( ) and throws another in response.
        Shared Sub Rethrow( )
            Try
                DivideBy0( )

            Catch ex As Exception
                Throw New ThirdLevelException( _
                    "Caught the second exception and " & _
                    "threw a third in response.", ex )
            End Try
        End Sub ' Rethrow
           
        ' This sub forces a division by 0 and throws a second 
        ' exception.
        Shared Sub DivideBy0( )
            Try
                Dim zero As Integer = 0
                Dim ecks As Integer = 1 \ zero

            Catch ex As Exception
                Throw New SecondLevelException( _
                    "Forced a division by 0 and threw " & _
                    "a second exception.", ex )
            End Try
        End Sub ' DivideBy0
    End Class ' NestedExceptions
End Namespace ' NDP_UE_VB

' This example of Exception.GetBaseException generates the following output.
' 
' The program forces a division by 0, then throws the exception
' twice more, using a different derived exception each time:
' 
' Unwind the nested exceptions using the InnerException property:
' 
' NDP_UE_VB.ThirdLevelException: Caught the second exception and threw a third
' in response. ---> NDP_UE_VB.SecondLevelException: Forced a division by 0 and
' threw a second exception. ---> System.DivideByZeroException: Attempted to div
' ide by zero.
'    at NDP_UE_VB.NestedExceptions.DivideBy0()
'    --- End of inner exception stack trace ---
'    at NDP_UE_VB.NestedExceptions.DivideBy0()
'    at NDP_UE_VB.NestedExceptions.Rethrow()
'    --- End of inner exception stack trace ---
'    at NDP_UE_VB.NestedExceptions.Rethrow()
'    at NDP_UE_VB.NestedExceptions.Main()
' 
' NDP_UE_VB.SecondLevelException: Forced a division by 0 and threw a second exc
' eption. ---> System.DivideByZeroException: Attempted to divide by zero.
'    at NDP_UE_VB.NestedExceptions.DivideBy0()
'    --- End of inner exception stack trace ---
'    at NDP_UE_VB.NestedExceptions.DivideBy0()
'    at NDP_UE_VB.NestedExceptions.Rethrow()
' 
' System.DivideByZeroException: Attempted to divide by zero.
'    at NDP_UE_VB.NestedExceptions.DivideBy0()
' 
' Display the base exception using the GetBaseException method:
' 
' System.DivideByZeroException: Attempted to divide by zero.
'    at NDP_UE_VB.NestedExceptions.DivideBy0()

// Example for the Exception.GetBaseException method.
using System;

namespace NDP_UE_CS
{
    // Define two derived exceptions to demonstrate nested exceptions.
    class SecondLevelException : Exception
    {
        public SecondLevelException( string message, Exception inner )
            : base( message, inner )
        { }
    }
    class ThirdLevelException : Exception
    {
        public ThirdLevelException( string message, Exception inner ) 
            : base( message, inner )
        { }
    }

    class NestedExceptions
    {
        public static void Main() 
        {
            Console.WriteLine( 
                "This example of Exception.GetBaseException " +
                "generates the following output." );
            Console.WriteLine( 
                "\nThe program forces a division by 0, then " +
                "throws the exception \ntwice more, " +
                "using a different derived exception each time.\n" );

            try
            {
                // This function calls another that forces a 
                // division by 0.
                Rethrow( );
            }
            catch( Exception ex )
            {
                Exception current;

                Console.WriteLine( 
                    "Unwind the nested exceptions " +
                    "using the InnerException property:\n" );

                // This code unwinds the nested exceptions using the 
                // InnerException property.
                current = ex;
                while( current != null )
                {
                    Console.WriteLine( current.ToString( ) );
                    Console.WriteLine( );
                    current = current.InnerException;
                }

                // Display the innermost exception.
                Console.WriteLine( 
                    "Display the base exception " +
                    "using the GetBaseException method:\n" );
                Console.WriteLine( 
                    ex.GetBaseException( ).ToString( ) );
            }
        }

        // This function catches the exception from the called 
        // function DivideBy0( ) and throws another in response.
        static void Rethrow()
        {
            try
            {
                DivideBy0( );
            }
            catch( Exception ex )
            {
                throw new ThirdLevelException( 
                    "Caught the second exception and " +
                    "threw a third in response.", ex );
            }
        }

        // This function forces a division by 0 and throws a second 
        // exception.
        static void DivideBy0( )
        {
            try
            {
                int  zero = 0;
                int  ecks = 1 / zero;
            }
            catch( Exception ex )
            {
                throw new SecondLevelException( 
                    "Forced a division by 0 and threw " +
                    "a second exception.", ex );
            }
        }
    }
}

/*
This example of Exception.GetBaseException generates the following output.

The program forces a division by 0, then throws the exception
twice more, using a different derived exception each time.

Unwind the nested exceptions using the InnerException property:

NDP_UE_CS.ThirdLevelException: Caught the second exception and threw a third in
 response. ---> NDP_UE_CS.SecondLevelException: Forced a division by 0 and thre
w a second exception. ---> System.DivideByZeroException: Attempted to divide by
 zero.
   at NDP_UE_CS.NestedExceptions.DivideBy0()
   --- End of inner exception stack trace ---
   at NDP_UE_CS.NestedExceptions.DivideBy0()
   at NDP_UE_CS.NestedExceptions.Rethrow()
   --- End of inner exception stack trace ---
   at NDP_UE_CS.NestedExceptions.Rethrow()
   at NDP_UE_CS.NestedExceptions.Main()

NDP_UE_CS.SecondLevelException: Forced a division by 0 and threw a second excep
tion. ---> System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CS.NestedExceptions.DivideBy0()
   --- End of inner exception stack trace ---
   at NDP_UE_CS.NestedExceptions.DivideBy0()
   at NDP_UE_CS.NestedExceptions.Rethrow()

System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CS.NestedExceptions.DivideBy0()

Display the base exception using the GetBaseException method:

System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CS.NestedExceptions.DivideBy0()
*/

// Example for the Exception::GetBaseException method.
using namespace System;

namespace NDP_UE_CPP
{

   // Define two derived exceptions to demonstrate nested exceptions.
   ref class SecondLevelException: public Exception
   {
   public:
      SecondLevelException( String^ message, Exception^ inner )
         : Exception( message, inner )
      {}

   };

   ref class ThirdLevelException: public Exception
   {
   public:
      ThirdLevelException( String^ message, Exception^ inner )
         : Exception( message, inner )
      {}

   };


   // DivideBy0 forces a division by 0 and throws a second exception.
   void DivideBy0()
   {
      try
      {
         int zero = 0;
         int ecks = 1 / zero;
      }
      catch ( Exception^ ex ) 
      {
         throw gcnew SecondLevelException( "Forced a division by 0 and threw "
         "a second exception.",ex );
      }

   }


   // This function catches the exception from the called function
   // DivideBy0( ) and throws another in response.
   void Rethrow()
   {
      try
      {
         DivideBy0();
      }
      catch ( Exception^ ex ) 
      {
         throw gcnew ThirdLevelException( "Caught the second exception and "
         "threw a third in response.",ex );
      }

   }

}

int main()
{
   Console::WriteLine( "This example of Exception.GetBaseException "
   "generates the following output." );
   Console::WriteLine( "\nThe program forces a division by 0, "
   "then throws the exception \ntwice more, "
   "using a different derived exception each time.\n" );
   try
   {
      
      // This function calls another that forces a division by 0.
      NDP_UE_CPP::Rethrow();
   }
   catch ( Exception^ e ) 
   {
      Exception^ current;
      Console::WriteLine( "Unwind the nested exceptions using "
      "the InnerException property:\n" );
      
      // This code unwinds the nested exceptions using the 
      // InnerException property.
      current = e;
      while ( current != (Object^)0 )
      {
         Console::WriteLine( current->ToString() );
         Console::WriteLine();
         current = current->InnerException;
      }
      
      // Display the innermost exception.
      Console::WriteLine( "Display the base exception using the \n"
      "GetBaseException method:\n" );
      Console::WriteLine( e->GetBaseException()->ToString() );
   }

}

/*
This example of Exception.GetBaseException generates the following output.

The program forces a division by 0, then throws the exception
twice more, using a different derived exception each time.

Unwind the nested exceptions using the InnerException property:

NDP_UE_CPP.ThirdLevelException: Caught the second exception and threw a third i
n response. ---> NDP_UE_CPP.SecondLevelException: Forced a division by 0 and th
rew a second exception. ---> System.DivideByZeroException: Attempted to divide
by zero.
   at NDP_UE_CPP.DivideBy0()
   --- End of inner exception stack trace ---
   at NDP_UE_CPP.DivideBy0()
   at NDP_UE_CPP.Rethrow()
   --- End of inner exception stack trace ---
   at NDP_UE_CPP.Rethrow()
   at main()

NDP_UE_CPP.SecondLevelException: Forced a division by 0 and threw a second exce
ption. ---> System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CPP.DivideBy0()
   --- End of inner exception stack trace ---
   at NDP_UE_CPP.DivideBy0()
   at NDP_UE_CPP.Rethrow()

System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CPP.DivideBy0()

Display the base exception using the
GetBaseException method:

System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_CPP.DivideBy0()
*/

// Example for the Exception.GetBaseException method.
package NDP_UE_JSL; 

import System.* ;

// Define two derived exceptions to demonstrate nested exceptions.
class SecondLevelException extends System.Exception
{
    public SecondLevelException(String message, System.Exception inner)
    {
        super(message, inner);
    } //SecondLevelException
} //SecondLevelException

class ThirdLevelException extends System.Exception
{
    public ThirdLevelException(String message, System.Exception inner)
    {
        super(message, inner);
    } //ThirdLevelException
} //ThirdLevelException

class NestedExceptions
{
    public static void main(String[] args)
    {
        Console.WriteLine(("This example of Exception.GetBaseException " 
            + "generates the following output."));
        Console.WriteLine(("\nThe program forces a division by 0, then " 
            + "throws the exception \ntwice more, " 
            + "using a different derived exception each time.\n"));
        try {
            // This function calls another that forces a 
            // division by 0.
            Rethrow();
        }
        catch (System.Exception ex) {
            System.Exception current;

            Console.WriteLine(("Unwind the nested exceptions " 
                + "using the InnerException property:\n"));

            // This code unwinds the nested exceptions using the 
            // InnerException property.
            current = ex;
            while ((current != null)) {
                Console.WriteLine(current.ToString());
                Console.WriteLine();
                current = current.get_InnerException();
            }

            // Display the innermost exception.
            Console.WriteLine(("Display the base exception " 
                + "using the GetBaseException method:\n"));
            Console.WriteLine(ex.GetBaseException().ToString());
        }
    } //main

    // This function catches the exception from the called 
    // function DivideBy0( ) and throws another in response.
    static void Rethrow() throws ThirdLevelException ,SecondLevelException
    {
        try {
            DivideBy0();
        }
        catch (System.Exception ex) {
            throw new ThirdLevelException("Caught the second exception and " 
                + "threw a third in response.", ex);
        }
    } //Rethrow

    // This function forces a division by 0 and throws a second 
    // exception.
    static void DivideBy0() throws SecondLevelException
    {
        try {
            int zero = 0;
            int ecks = 1 / zero;
        }
        catch (System.Exception ex) {
            throw new SecondLevelException(
                "Forced a division by 0 and threw " 
                + "a second exception.", ex);
        }
    } //DivideBy0
} //NestedExceptions
   
/*
This example of Exception.GetBaseException generates the following output.

The program forces a division by 0, then throws the exception
twice more, using a different derived exception each time.

Unwind the nested exceptions using the InnerException property:

NDP_UE_JSL.ThirdLevelException: Caught the second exception and threw a third in
 response. ---> NDP_UE_JSL.SecondLevelException: Forced a division by 0 and thre
w a second exception. ---> System.DivideByZeroException: Attempted to divide by
zero.
   at NDP_UE_JSL.NestedExceptions.DivideBy0() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 79
   --- End of inner exception stack trace ---
   at NDP_UE_JSL.NestedExceptions.DivideBy0() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 82
   at NDP_UE_JSL.NestedExceptions.Rethrow() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\Cl
ass1.jsl:line 65
   --- End of inner exception stack trace ---
   at NDP_UE_JSL.NestedExceptions.Rethrow() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\Cl
ass1.jsl:line 68
   at NDP_UE_JSL.NestedExceptions.main(String[] args) in C:\Documents and 
Settings\My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleA
pp - JS\Class1.jsl:line 36

NDP_UE_JSL.SecondLevelException: Forced a division by 0 and threw a second 
exception. ---> System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_JSL.NestedExceptions.DivideBy0() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 79
   --- End of inner exception stack trace ---
   at NDP_UE_JSL.NestedExceptions.DivideBy0() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 82
   at NDP_UE_JSL.NestedExceptions.Rethrow() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\Cl
ass1.jsl:line 65

System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_JSL.NestedExceptions.DivideBy0() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 79

Display the base exception using the GetBaseException method:

System.DivideByZeroException: Attempted to divide by zero.
   at NDP_UE_JSL.NestedExceptions.DivideBy0() in C:\Documents and Settings\
   My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 79
*/