Exception.Message Proprietà

public:
 virtual property System::String ^ Message { System::String ^ get(); };

public virtual string Message { get; }

member this.Message : string

Public Overridable ReadOnly Property Message As String

Valore della proprietà

Messaggio di errore che spiega il motivo dell'eccezione o una stringa vuota ("").

Implementazioni

Esempio

L'esempio di codice seguente genera e quindi intercetta un'eccezione Exception e visualizza il messaggio di testo dell'eccezione usando la proprietà Message.

// Example for the Exception.HelpLink, Exception.Source,
// Exception.StackTrace, and Exception.TargetSite properties.
using System;

namespace NDP_UE_CS
{
    // Derive an exception; the constructor sets the HelpLink and
    // Source properties.
    class LogTableOverflowException : Exception
    {
        const string overflowMessage = "The log table has overflowed.";

        public LogTableOverflowException(
            string auxMessage, Exception inner ) :
                base( String.Format( "{0} - {1}",
                    overflowMessage, auxMessage ), inner )
        {
            this.HelpLink = "https://dotnet.territoriali.olinfo.it";
            this.Source = "Exception_Class_Samples";
        }
    }

    class LogTable
    {
        public LogTable( int numElements )
        {
            logArea = new string[ numElements ];
            elemInUse = 0;
        }

        protected string[ ] logArea;
        protected int       elemInUse;

        // The AddRecord method throws a derived exception if
        // the array bounds exception is caught.
        public    int       AddRecord( string newRecord )
        {
            try
            {
                logArea[ elemInUse ] = newRecord;
                return elemInUse++;
            }
            catch( Exception e )
            {
                throw new LogTableOverflowException(
                    String.Format( "Record \"{0}\" was not logged.",
                        newRecord ), e );
            }
        }
    }

    class OverflowDemo
    {
        // Create a log table and force an overflow.
        public static void Main()
        {
            LogTable log = new LogTable( 4 );

            Console.WriteLine(
                "This example of \n   Exception.Message, \n" +
                "   Exception.HelpLink, \n   Exception.Source, \n" +
                "   Exception.StackTrace, and \n   Exception." +
                "TargetSite \ngenerates the following output." );

            try
            {
                for( int count = 1; ; count++ )
                {
                    log.AddRecord(
                        String.Format(
                            "Log record number {0}", count ) );
                }
            }
            catch( Exception ex )
            {
                Console.WriteLine( "\nMessage ---\n{0}", ex.Message );
                Console.WriteLine(
                    "\nHelpLink ---\n{0}", ex.HelpLink );
                Console.WriteLine( "\nSource ---\n{0}", ex.Source );
                Console.WriteLine(
                    "\nStackTrace ---\n{0}", ex.StackTrace );
                Console.WriteLine(
                    "\nTargetSite ---\n{0}", ex.TargetSite );
            }
        }
    }
}

/*
This example of
   Exception.Message,
   Exception.HelpLink,
   Exception.Source,
   Exception.StackTrace, and
   Exception.TargetSite
generates the following output.

Message ---
The log table has overflowed. - Record "Log record number 5" was not logged.

HelpLink ---
https://dotnet.territoriali.olinfo.it

Source ---
Exception_Class_Samples

StackTrace ---
   at NDP_UE_CS.LogTable.AddRecord(String newRecord)
   at NDP_UE_CS.OverflowDemo.Main()

TargetSite ---
Int32 AddRecord(System.String)
*/

// Example for the Exception.HelpLink, Exception.Source,
// Exception.StackTrace, and Exception.TargetSite properties.
open System
        
let overflowMessage = "The log table has overflowed."

// Derive an exception; the constructor sets the HelpLink and
// Source properties.
type LogTableOverflowException(auxMessage, inner) as this =
    inherit Exception($"%s{overflowMessage} - %s{auxMessage}", inner)

    do
        this.HelpLink <- "https://dotnet.territoriali.olinfo.it"
        this.Source <- "Exception_Class_Samples"

type LogTable(numElements) =
    let logArea = Array.zeroCreate<string> numElements
    let mutable elemInUse = 0

    // The AddRecord method throws a derived exception if
    // the array bounds exception is caught.
    member this.AddRecord(newRecord) =
        try
            logArea[elemInUse] <- newRecord
            elemInUse <- elemInUse + 1
            elemInUse - 1 
        with e ->
            raise (LogTableOverflowException($"Record \"{newRecord}\" was not logged.", e) )

// Create a log table and force an overflow.
let log = LogTable 4 

printfn
    """This example of
   Exception.Message, 
   Exception.HelpLink, 
   Exception.Source, 
   Exception.StackTrace, and
   Exception.TargetSite 
   generates the following output."""

try
    for count = 1 to 1000000 do
        log.AddRecord $"Log record number {count}"
        |> ignore
with ex ->
    printfn $"\nMessage ---\n{ex.Message}"
    printfn $"\nHelpLink ---\n{ex.HelpLink}"
    printfn $"\nSource ---\n{ex.Source}"
    printfn $"\nStackTrace ---\n{ex.StackTrace}"
    printfn $"\nTargetSite ---\n{ex.TargetSite}"

// This example of
//    Exception.Message,
//    Exception.HelpLink,
//    Exception.Source,
//    Exception.StackTrace, and
//    Exception.TargetSite
// generates the following output.

// Message ---
// The log table has overflowed. - Record "Log record number 5" was not logged.

// HelpLink ---
// https://dotnet.territoriali.olinfo.it

// Source ---
// Exception_Class_Samples

// StackTrace ---
//    at NDP_UE_FS.LogTable.AddRecord(String newRecord)
//    at <StartupCode$fs>.$NDP_UE_FS.main@()

// TargetSite ---
// Int32 AddRecord(System.String)

' Example for the Exception.HelpLink, Exception.Source,
' Exception.StackTrace, and Exception.TargetSite properties.
Namespace NDP_UE_VB

    ' Derive an exception; the constructor sets the HelpLink and 
    ' Source properties.
    Class LogTableOverflowException
        Inherits Exception

        Private Const overflowMessage As String = _
            "The log table has overflowed."
           
        Public Sub New( auxMessage As String, inner As Exception )
            MyBase.New( String.Format( "{0} - {1}", _
                overflowMessage, auxMessage ), inner )

            Me.HelpLink = "https://dotnet.territoriali.olinfo.it"
            Me.Source = "Exception_Class_Samples"

        End Sub
    End Class

    Class LogTable
       
        Public Sub New(numElements As Integer)
            logArea = New String(numElements) {}
            elemInUse = 0
        End Sub
           
        Protected logArea() As String
        Protected elemInUse As Integer
           
        ' The AddRecord method throws a derived exception if 
        ' the array bounds exception is caught.
        Public Function AddRecord( newRecord As String ) As Integer

            Try
                Dim curElement as Integer = elemInUse
                logArea( elemInUse ) = newRecord
                elemInUse += 1
                Return curElement

            Catch ex As Exception
                Throw New LogTableOverflowException( _
                    String.Format( "Record ""{0}"" was not logged.", _
                        newRecord ), ex )
            End Try
        End Function ' AddRecord
    End Class

    Module OverflowDemo
       
        ' Create a log table and force an overflow.
        Sub Main( )
            Dim log As New LogTable( 4 )
              
            Console.WriteLine( "This example of " & vbCrLf & _
                "   Exception.Message, " & vbCrLf & _
                "   Exception.HelpLink, " & vbCrLf & _
                "   Exception.Source, " & vbCrLf & _
                "   Exception.StackTrace, and " & vbCrLf & _
                "   Exception.TargetSite " & vbCrLf & _
                "generates the following output." )
              
            Try
                Dim count As Integer = 0
                 
                Do
                    log.AddRecord( _
                        String.Format( "Log record number {0}", count ) )
                    count += 1
                Loop

            Catch ex As Exception
                Console.WriteLine( vbCrLf & _
                    "Message ---" & vbCrLf & ex.Message )
                Console.WriteLine( vbCrLf & _
                    "HelpLink ---" & vbCrLf & ex.HelpLink )
                Console.WriteLine( vbCrLf & _
                    "Source ---" & vbCrLf & ex.Source )
                Console.WriteLine( vbCrLf & _
                    "StackTrace ---" & vbCrLf & ex.StackTrace )
                Console.WriteLine( vbCrLf & "TargetSite ---" & _
                    vbCrLf & ex.TargetSite.ToString( ) )
            End Try
        End Sub

    End Module ' OverflowDemo
End Namespace ' NDP_UE_VB

' This example of
'    Exception.Message,
'    Exception.HelpLink,
'    Exception.Source,
'    Exception.StackTrace, and
'    Exception.TargetSite
' generates the following output.
' 
' Message ---
' The log table has overflowed. - Record "Log record number 5" was not logged.
' 
' HelpLink ---
' https://dotnet.territoriali.olinfo.it
' 
' Source ---
' Exception_Class_Samples
' 
' StackTrace ---
'    at NDP_UE_VB.LogTable.AddRecord(String newRecord)
'    at NDP_UE_VB.OverflowDemo.Main()
' 
' TargetSite ---
' Int32 AddRecord(System.String)

Commenti

I messaggi di errore sono destinati allo sviluppatore che gestisce l'eccezione. Il testo della proprietà Message deve descrivere completamente l'errore e, quando possibile, deve spiegare anche come correggere l'errore. I gestori di eccezioni di primo livello possono visualizzare il messaggio agli utenti finali, pertanto è necessario assicurarsi che sia grammaticalmente corretto e che ogni frase del messaggio termini con un punto. Non utilizzare punti interrogativi o punti esclamativi. Se l'applicazione usa messaggi di eccezione localizzati, assicurarsi che vengano tradotti in modo accurato.

Il valore della proprietà Message è incluso nelle informazioni restituite da ToString. La proprietà Message viene impostata solo quando si crea un Exception. Se non è stato fornito alcun messaggio al costruttore per l'istanza corrente, il sistema fornisce un messaggio predefinito formattato utilizzando le impostazioni cultura di sistema correnti.

Note per gli eredi

La Message proprietà viene sottoposta a override nelle classi che richiedono il controllo sul contenuto o sul formato del messaggio. Il codice dell'applicazione accede in genere a questa proprietà quando deve visualizzare informazioni su un'eccezione rilevata.

Il messaggio di errore deve essere localizzato.