This documentation is archived and is not being maintained.

Exception.Exception(String) Constructor

Initializes a new instance of the Exception class with a specified error message.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

'Declaration
Public Sub New ( _
	message As String _
)
'Usage
Dim message As String

Dim instance As New Exception(message)
public Exception (
	String message
)
public function Exception (
	message : String
)
Not applicable.

Parameters

message

The message that describes the error.

This constructor initializes the Message property of the new instance using the message parameter.

The following table shows the initial property values for an instance of Exception.

Property

Value

InnerException

A null reference (Nothing in Visual Basic).

Message

The error message string.

The following code example derives an Exception for a specific condition. The code demonstrates the use of the constructor that takes a caller-specified message as a parameter, for both the derived class and the base Exception class.

' Example for the Exception( String ) constructor( String ).
Imports System
Imports Microsoft.VisualBasic

Namespace NDP_UE_VB

    ' Derive an exception with a specifiable message.
    Class NotEvenException
        Inherits Exception

        Private Const notEvenMessage As String = _
            "The argument to a function requiring " & _
            "even input is not divisible by 2."
           
        Public Sub New()
            MyBase.New(notEvenMessage)
        End Sub ' New
           
        Public Sub New(auxMessage As String)
            MyBase.New(String.Format("{0} - {1}", _
                auxMessage, notEvenMessage))
        End Sub ' New
    End Class ' NotEvenException

    Module NewSExceptionDemo
       
        Sub Main()
            Console.WriteLine( _
                "This example of the Exception( String )" & vbCrLf & _
                "constructor generates the following output." )
            Console.WriteLine( vbCrLf & _
                "Here, an exception is thrown using the " & vbCrLf & _
                "constructor of the base class." & vbCrLf )

            CalcHalf(18)
            CalcHalf(21)
              
            Console.WriteLine(vbCrLf & _
                "Here, an exception is thrown using the " & vbCrLf & _
                "constructor of a derived class." & vbCrLf )

            CalcHalf2(30)
            CalcHalf2(33)
        End Sub ' Main
           
        ' Half throws a base exception if the input is not even.
        Function Half(input As Integer) As Integer

            If input Mod 2 <> 0 Then
                Throw New Exception( String.Format( _
                    "The argument {0} is not divisible by 2.", _
                    input ) )
            Else
                Return input / 2
            End If
        End Function ' Half
            
        ' Half2 throws a derived exception if the input is not even.
        Function Half2(input As Integer) As Integer

            If input Mod 2 <> 0 Then
                Throw New NotEvenException( _
                    String.Format( "Invalid argument: {0}", input ) )
            Else
                Return input / 2
            End If
        End Function ' Half2
            
        ' CalcHalf calls Half and catches any thrown exceptions.
        Sub CalcHalf(input As Integer)

            Try
                Dim halfInput As Integer = Half(input)
                Console.WriteLine( _
                    "Half of {0} is {1}.", input, halfInput )

            Catch ex As Exception
                Console.WriteLine( ex.ToString( ) )
            End Try
        End Sub ' CalcHalf
           
           
        ' CalcHalf2 calls Half2 and catches any thrown exceptions.
        Sub CalcHalf2( input As Integer )

            Try
                Dim halfInput As Integer = Half2( input )
                Console.WriteLine( _
                    "Half of {0} is {1}.", input, halfInput )

            Catch ex As Exception
                Console.WriteLine( ex.ToString( ) )
            End Try
        End Sub ' CalcHalf2

    End Module ' NewSExceptionDemo
End Namespace ' NDP_UE_VB

' This example of the Exception( String )
' constructor generates the following output.
' 
' Here, an exception is thrown using the
' constructor of the base class.
' 
' Half of 18 is 9.
' System.Exception: The argument 21 is not divisible by 2.
'    at NDP_UE_VB.NewSExceptionDemo.Half(Int32 input)
'    at NDP_UE_VB.NewSExceptionDemo.CalcHalf(Int32 input)
' 
' Here, an exception is thrown using the
' constructor of a derived class.
' 
' Half of 30 is 15.
' NDP_UE_VB.NotEvenException: Invalid argument: 33 - The argument to a function
'  requiring even input is not divisible by 2.
'    at NDP_UE_VB.NewSExceptionDemo.Half2(Int32 input)
'    at NDP_UE_VB.NewSExceptionDemo.CalcHalf2(Int32 input)

// Example for the Exception( string ) constructor.
package NDP_UE_JSL; 

import System.* ;

// Derive an exception with a specifiable message.
class NotEvenException extends System.Exception
{
    private String notEvenMessage = "The argument to a function requiring " 
        + "even input is not divisible by 2.";

    public NotEvenException()
    {
        super("The argument to a function requiring " 
            + "even input is not divisible by 2.");
    } //NotEvenException

    public NotEvenException(String auxMessage)
    {
        super(String.Format("{0} - " + "The argument to a function requiring " 
            + "even input is not divisible by 2.", auxMessage));
    } //NotEvenException
} //NotEvenException

class NewSExceptionDemo
{
    public static void main(String[] args)
    {
        Console.WriteLine(("This example of the Exception( string )\n" 
            + "constructor generates the following output."));
        Console.WriteLine(("\nHere, an exception is thrown using the \n" 
            + "constructor of the base class.\n"));
        CalcHalf(18);
        CalcHalf(21);
        Console.WriteLine(("\nHere, an exception is thrown using the \n" 
            + "constructor of a derived class.\n"));
        CalcHalf2(30);
        CalcHalf2(33);
    } //main

    // Half throws a base exception if the input is not even.
    static int Half(int input) throws System.Exception
    {
        if (input % 2 != 0) {
            throw new System.Exception(String.Format(
                    "The argument {0} is not divisible by 2.", 
                    System.Convert.ToString(input)));
        }
        else {
            return input / 2;
        }
    } //Half

    // Half2 throws a derived exception if the input is not even.
    static int Half2(int input) throws NotEvenException
    {
        if (input % 2 != 0) {
            throw new NotEvenException(String.Format("Invalid argument: {0}",
                    System.Convert.ToString(input)));
        }
        else {
            return input / 2;
        }
    } //Half2

    // CalcHalf calls Half and catches any thrown exceptions.
    static void CalcHalf(int input)
    {
        try {
            int halfInput = Half(input);

            Console.WriteLine("Half of {0} is {1}.", 
                System.Convert.ToString(input), 
                System.Convert.ToString(halfInput));
        }
        catch (System.Exception ex) {
            Console.WriteLine(ex.toString());
        }
    } //CalcHalf

    // CalcHalf2 calls Half2 and catches any thrown exceptions.
    static void CalcHalf2(int input)
    {
        try {
            int halfInput = Half2(input);

            Console.WriteLine("Half of {0} is {1}.", 
                System.Convert.ToString(input), 
                System.Convert.ToString(halfInput));
        }
        catch (System.Exception ex) {
            Console.WriteLine(ex.toString());
        }
    } //CalcHalf2
} //NewSExceptionDemo
   
/*
This example of the Exception( string )
constructor generates the following output.

Here, an exception is thrown using the
constructor of the base class.

Half of 18 is 9.
System.Exception: The argument 21 is not divisible by 2.
   at NDP_UE_JSL.NewSExceptionDemo.Half(Int32 input) in C:\Documents and Setting
s\jitesh_chourasia\My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleAp
p - JS\Class1.jsl:line 47
   at NDP_UE_JSL.NewSExceptionDemo.CalcHalf(Int32 input) in C:\Documents and Set
tings\jitesh_chourasia\My Documents\Visual Studio Projects\ConsoleApp - JS\Conso
leApp - JS\Class1.jsl:line 72

Here, an exception is thrown using the
constructor of a derived class.

Half of 30 is 15.
NDP_UE_JSL.NotEvenException: Invalid argument: 33 - The argument to a function r
equiring even input is not divisible by 2.
   at NDP_UE_JSL.NewSExceptionDemo.Half2(Int32 input) in C:\Documents and Settin
gs\My Documents\Visual Studio Projects\ConsoleApp - JS\ConsoleApp - JS\
Class1.jsl:line 60
   at NDP_UE_JSL.NewSExceptionDemo.CalcHalf2(Int32 input) in C:\Documents and Se
ttings\My Documents\Visual Studio Projects\ConsoleApp - JS\Cons
oleApp - JS\Class1.jsl:line 87
*/

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0
Show: