Exception.GetBaseException Metod

public:
 virtual Exception ^ GetBaseException();

public virtual Exception GetBaseException();

abstract member GetBaseException : unit -> Exception
override this.GetBaseException : unit -> Exception

Public Overridable Function GetBaseException () As Exception

Returer

Det första undantaget utlöses i en undantagskedja. Om egenskapen InnerException för det aktuella undantaget är en null-referens (Nothing i Visual Basic) returnerar den här egenskapen det aktuella undantaget.

Implementeringar

Exempel

I följande kodexempel definieras två härledda Exception klasser. Det tvingar fram ett undantag och kastar det sedan igen med var och en av de härledda klasserna. Koden visar hur metoden används GetBaseException för att hämta det ursprungliga undantaget.

// 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.
open System

// Define two derived exceptions to demonstrate nested exceptions.
type SecondLevelException(message, inner: Exception) =
    inherit Exception(message, inner)

type ThirdLevelException(message, inner: Exception) = 
    inherit Exception(message, inner)

printfn 
    """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.
"""


// This function forces a division by 0 and throws a second exception.
let divideBy0 () =
    try
        let zero = 0
        let ecks = 1 / zero
        ()
    with ex ->
        raise (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.
let rethrow () =
    try
        divideBy0 ()
    with ex ->
        raise (ThirdLevelException("Caught the second exception and threw a third in response.", ex) )

try
    // This function calls another that forces a
    // division by 0.
    rethrow ()
with ex ->
    printfn "Unwind the nested exceptions using the InnerException property:\n"

    // This code unwinds the nested exceptions using the
    // InnerException property.
    let mutable current = ex
    while current <> null do
        printfn $"{current}\n"
        current <- current.InnerException

    // Display the innermost exception.
    printfn "Display the base exception using the GetBaseException method:\n"
    printfn $"{ex.GetBaseException()}"


// 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_FS+ThirdLevelException: Caught the second exception and threw a third in
//  response. ---> NDP_UE_FS.SecondLevelException: Forced a division by 0 and thre
// w a second exception. ---> System.DivideByZeroException: Attempted to divide by
//  zero.
//    at NDP_UE_FS.divideBy0()
//    --- End of inner exception stack trace ---
//    at NDP_UE_FS.divideBy0()
//    at NDP_UE_FS.rethrow()
//    --- End of inner exception stack trace ---
//    at NDP_UE_FS.rethrow()
//    at<StartupCode$fs>.$NDP_UE_FS.main@()
//
// NDP_UE_FS.SecondLevelException: Forced a division by 0 and threw a second excep
// tion. ---> System.DivideByZeroException: Attempted to divide by zero.
//    at NDP_UE_FS.divideBy0()
//    --- End of inner exception stack trace ---
//    at NDP_UE_FS.divideBy0()
//    at NDP_UE_FS.rethrow()
//
// System.DivideByZeroException: Attempted to divide by zero.
//    at NDP_UE_FS.divideBy0()
//
// Display the base exception using the GetBaseException method:
//
// System.DivideByZeroException: Attempted to divide by zero.
//    at NDP_UE_FS.divideBy0()

' Example for the Exception.GetBaseException method.
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
    End Class

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

    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
           
        ' 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
           
        ' 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
    End Class
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()

Kommentarer

En undantagskedja består av en uppsättning undantag som gör att varje undantag i kedjan utlöses som ett direkt resultat av undantaget som refereras till i dess InnerException egenskap. För en viss kedja kan det finnas exakt ett undantag som är rotorsaken till alla andra undantag i kedjan. Det här undantaget kallas för basfelet och dess InnerException egenskap innehåller alltid en null-referens.

För alla undantag i en undantagskedja GetBaseException måste metoden returnera samma objekt (basfelet).

Använd metoden GetBaseException när du vill hitta rotorsaken till ett undantag men inte behöver information om undantag som kan ha inträffat mellan det aktuella undantaget och det första undantaget.

Anteckningar till arvingar

Metoden GetBaseException åsidosätts i klasser som kräver kontroll över undantagsinnehållet eller formatet.