NotSupportedException Klasse

Definition

Die Ausnahme, die ausgelöst wird, wenn eine aufgerufene Methode nicht unterstützt wird oder versucht wird, in einem Stream, der die aufgerufenen Funktionen nicht unterstützt, zu lesen, zu suchen oder zu schreiben.The exception that is thrown when an invoked method is not supported, or when there is an attempt to read, seek, or write to a stream that does not support the invoked functionality.

public ref class NotSupportedException : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class NotSupportedException : SystemException
type NotSupportedException = class
    inherit SystemException
Public Class NotSupportedException
Inherits SystemException
Vererbung
NotSupportedException
Abgeleitet
Attribute

Hinweise

NotSupportedExceptionGibt an, dass für eine aufgerufene Methode oder Eigenschaft keine Implementierung vorhanden ist.NotSupportedException indicates that no implementation exists for an invoked method or property.

NotSupportedExceptionverwendet das HRESULT-COR_E_NOTSUPPORTED, das den Wert 0x80131515 aufweist.NotSupportedException uses the HRESULT COR_E_NOTSUPPORTED, which has the value 0x80131515.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von NotSupportedException, finden Sie unter den NotSupportedException Konstruktoren.For a list of initial property values for an instance of NotSupportedException, see the NotSupportedException constructors.

Auslösen einer NotSupportedException-AusnahmeThrowing a NotSupportedException exception

In den folgenden Fällen sollten NotSupportedException Sie eine Ausnahme auslösen:You might consider throwing a NotSupportedException exception in the following cases:

  • Sie implementieren eine allgemeine Schnittstelle, und die Anzahl der Methoden hat keine sinnvolle Implementierung.You are implementing a general-purpose interface, and number of the methods have no meaningful implementation. Wenn Sie z. b. einen Datums-und Uhrzeittyp erstellen IConvertible , der die-Schnittstelle NotSupportedException implementiert, lösen Sie eine-Ausnahme für die meisten Konvertierungen aus.For example, if you are creating a date and time type that implements the IConvertible interface, you would throw a NotSupportedException exception for most of the conversions.

  • Sie haben von einer abstrakten Klasse geerbt, die erfordert, dass Sie eine Reihe von Methoden überschreiben.You've inherited from an abstract class that requires that you override a number of methods. Sie sind jedoch nur darauf vorbereitet, eine Implementierung für eine Teilmenge dieser bereitzustellen.However, you're only prepared to provide an implementation for a subset of these. Für die Methoden, die Sie nicht implementieren möchten, können Sie eine NotSupportedExceptionauslösen.For the methods that you decide not to implement, you can choose to throw a NotSupportedException.

  • Sie definieren einen allgemeinen Typ mit einem Zustand, der Vorgänge bedingt ermöglicht.You are defining a general-purpose type with a state that enables operations conditionally. Beispielsweise kann der Typ entweder schreibgeschützt oder Lese-/Schreibzugriff sein.For example, your type can be either read-only or read-write. In diesem Fall gilt Folgendes:In that case:

    • Wenn das Objekt schreibgeschützt ist, sollte beim Versuch, den Eigenschaften einer Instanz Werte zuzuweisen, oder beim Abrufen von Methoden, die den Instanzzustand ändern, eine NotSupportedException -Ausnahme ausgelöst werden.If the object is read-only, attempting to assign values to the properties of an instance or call methods that modify instance state should throw a NotSupportedException exception.

    • Sie sollten eine Eigenschaft implementieren, die einen Boolean Wert zurückgibt, der angibt, ob eine bestimmte Funktionalität verfügbar ist.You should implement a property that returns a Boolean value that indicates whether particular functionality is available. Beispielsweise könnten Sie für einen Typ, der entweder schreibgeschützt oder Lese-/Schreibzugriff sein kann, IsReadOnly eine Eigenschaft implementieren, die angibt, ob der Satz von Lese-/Schreibmethoden verfügbar oder nicht verfügbar ist.For example, for a type that can be either read-only or read-write, you could implement a IsReadOnly property that indicates whether the set of read-write methods are available or unavailable.

Behandeln einer NotSupportedException-AusnahmeHandling a NotSupportedException exception

Die NotSupportedException -Ausnahme gibt an, dass eine Methode keine Implementierung hat und dass Sie nicht aufgerufen werden sollte.The NotSupportedException exception indicates that a method has no implementation and that you should not call it. Sie sollten die Ausnahme nicht behandeln.You should not handle the exception. Was Sie tun sollten, hängt von der Ursache der Ausnahme ab: ob eine Implementierung vollständig fehlt oder der Element Aufruf mit dem Zweck eines Objekts inkonsistent ist (z. b. ein Aufruf der FileStream.Write -Methode für ein FileStream Schreib geschütztes Objekt). .Instead, what you should do depends on the cause of the exception: whether an implementation is completely absent , or the member invocation is inconsistent with the purpose of an object (such as a call to the FileStream.Write method on a read-only FileStream object .

Es wurde keine Implementierung bereitgestellt, da der Vorgang nicht auf sinnvolle Weise ausgeführt werden kann.An implementation has not been provided because the operation cannot be performed in a meaningful way.
Dies ist eine häufige Ausnahme, wenn Sie Methoden für ein Objekt aufrufen, das Implementierungen für die Methoden einer abstrakten Basisklasse bereitstellt oder eine allgemeine Schnittstelle implementiert, und die Methode über keine sinnvolle Implementierung verfügt.This is a common exception when you are calling methods on an object that provides implementations for the methods of an abstract base class, or that implements a general-purpose interface, and the method has no meaningful implementation.

Beispielsweise implementiert die Convert -Klasse die IConvertible -Schnittstelle, d. h., Sie muss eine-Methode enthalten, um jeden primitiven Typ in jeden anderen primitiven Typ zu konvertieren.For example, the Convert class implements the IConvertible interface, which means that it must include a method to convert every primitive type to every other primitive type. Viele dieser Konvertierungen sind jedoch nicht möglich.Many of those conversions, however, are not possible. Folglich Convert.ToBoolean(DateTime) löst ein aufzurufende-Methode beispielsweise eine NotSupportedException -Ausnahme aus, da es keine mögliche Konvertierung zwischen einem DateTime -Wert und Boolean einem-Wert gibt.As a result, a call to the Convert.ToBoolean(DateTime) method, for instance, throws a NotSupportedException exception because there is no possible conversion between a DateTime and a Boolean value

Um die Ausnahme zu vermeiden, sollten Sie den-Methoden aufzurufen.To eliminate the exception, you should eliminate the method call.

Der Methoden aufrufwird aufgrund des Zustands des Objekts nicht unterstützt.The method call is not supported given the state of the object.
Sie versuchen, einen Member aufzurufen, dessen Funktionalität aufgrund des Zustands des Objekts nicht verfügbar ist.You are attempting to invoke a member whose functionality is unavailable because of the object's state. Sie können die Ausnahme auf eine von drei Arten entfernen:You can eliminate the exception in one of three ways:

  • Sie kennen den Zustand des Objekts im voraus, aber Sie haben eine nicht unterstützte Methode oder Eigenschaft aufgerufen.You know the state of the object in advance, but you've invoked an unsupported method or property. In diesem Fall ist der Element Aufruf ein Fehler, und Sie können ihn entfernen.In this case, the member invocation is an error, and you can eliminate it.

  • Sie wissen den Zustand des Objekts im Voraus (in der Regel, weil der Code es instanziiert hat), das Objekt ist jedoch falsch konfiguriert.You know the state of the object in advance (usually because your code has instantiated it), but the object is mis-configured. Dieses Problem wird im folgenden Beispiel veranschaulicht.The following example illustrates this issue. Es wird ein Schreib geschütztes- FileStream Objekt erstellt, und anschließend wird versucht, darauf zu schreiben.It creates a read-only FileStream object and then attempts to write to it.

    using System;
    using System.IO;
    using System.Text;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static async Task Main()
       {
          Encoding enc = Encoding.Unicode;
          String value = "This is a string to persist.";
          Byte[] bytes  = enc.GetBytes(value);
    
          FileStream fs = new FileStream(@".\TestFile.dat", 
                                         FileMode.Open,
                                         FileAccess.Read);
          Task t = fs.WriteAsync(enc.GetPreamble(), 0, enc.GetPreamble().Length);
          Task t2 = t.ContinueWith( (a) => fs.WriteAsync(bytes, 0, bytes.Length) ); 
          await t2;
          fs.Close();
       }
    }
    // The example displays the following output:
    //    Unhandled Exception: System.NotSupportedException: Stream does not support writing.
    //       at System.IO.Stream.BeginWriteInternal(Byte[] buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state
    //    , Boolean serializeAsynchronously)
    //       at System.IO.FileStream.BeginWrite(Byte[] array, Int32 offset, Int32 numBytes, AsyncCallback userCallback, Object sta
    //    teObject)
    //       at System.IO.Stream.<>c.<BeginEndWriteAsync>b__53_0(Stream stream, ReadWriteParameters args, AsyncCallback callback,
    //    Object state)
    //       at System.Threading.Tasks.TaskFactory`1.FromAsyncTrim[TInstance,TArgs](TInstance thisRef, TArgs args, Func`5 beginMet
    //    hod, Func`3 endMethod)
    //       at System.IO.Stream.BeginEndWriteAsync(Byte[] buffer, Int32 offset, Int32 count)
    //       at System.IO.FileStream.WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
    //       at System.IO.Stream.WriteAsync(Byte[] buffer, Int32 offset, Int32 count)
    //       at Example.Main()
    
    Imports System.IO
    Imports System.Text
    Imports System.Threading.Tasks
    
    Module Example
       Public Sub Main()
          Dim enc As Encoding = Encoding.Unicode
          Dim value As String = "This is a string to persist."
          Dim bytes() As Byte = enc.GetBytes(value)
    
          Dim fs As New FileStream(".\TestFile.dat", 
                                   FileMode.Open,
                                   FileAccess.Read)
          Dim t As Task = fs.WriteAsync(enc.GetPreamble(), 0, enc.GetPreamble().Length)
          Dim t2 As Task = t.ContinueWith(Sub(a) fs.WriteAsync(bytes, 0, bytes.Length)) 
          t2.Wait()
          fs.Close()
       End Sub
    End Module
    ' The example displays the following output:
    '    Unhandled Exception: System.NotSupportedException: Stream does not support writing.
    '       at System.IO.Stream.BeginWriteInternal(Byte[] buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state
    '    , Boolean serializeAsynchronously)
    '       at System.IO.FileStream.BeginWrite(Byte[] array, Int32 offset, Int32 numBytes, AsyncCallback userCallback, Object sta
    '    teObject)
    '       at System.IO.Stream.<>c.<BeginEndWriteAsync>b__53_0(Stream stream, ReadWriteParameters args, AsyncCallback callback,
    '    Object state)
    '       at System.Threading.Tasks.TaskFactory`1.FromAsyncTrim[TInstance,TArgs](TInstance thisRef, TArgs args, Func`5 beginMet
    '    hod, Func`3 endMethod)
    '       at System.IO.Stream.BeginEndWriteAsync(Byte[] buffer, Int32 offset, Int32 count)
    '       at System.IO.FileStream.WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
    '       at System.IO.Stream.WriteAsync(Byte[] buffer, Int32 offset, Int32 count)
    '       at Example.Main()
    

    Sie können die Ausnahme eliminieren, indem Sie sicherstellen, dass das instanziierte Objekt die gewünschte Funktionalität unterstützt.You can eliminate the exception by ensuring that the instantiated object supports the functionality you intend. Im folgenden Beispiel wird das Problem des schreibgeschützten- FileStream Objekts behoben, indem die richtigen Argumente für den FileStream.FileStream(String, FileMode, FileAccess) Konstruktor bereitgestellt werden.The following example addresses the problem of the read-only FileStream object by providing the correct arguments to the FileStream.FileStream(String, FileMode, FileAccess) constructor.

  • Der Status des Objekts ist im Voraus nicht bekannt, und das Objekt unterstützt keinen bestimmten Vorgang.You don't know the state of the object in advance, and the object doesn't support a particular operation. In den meisten Fällen sollte das Objekt eine Eigenschaft oder eine Methode enthalten, die angibt, ob ein bestimmter Satz von Vorgängen unterstützt wird.In most cases, the object should include a property or method that indicates whether it supports a particular set of operations. Sie können die Ausnahme eliminieren, indem Sie den Wert des Objekts überprüfen und den Member nur bei Bedarf aufrufen.You can eliminate the exception by checking the value of the object and invoking the member only if appropriate.

    Im folgenden Beispiel wird eine DetectEncoding -Methode definiert, NotSupportedException die eine-Ausnahme auslöst, wenn versucht wird, vom Anfang eines Streams zu lesen, der keinen Lesezugriff unterstützt.The following example defines a DetectEncoding method that throws a NotSupportedException exception when it attempts to read from the beginning of a stream that does not support read access.

    using System;
    using System.IO;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static async Task Main()
       {
          String name = @".\TestFile.dat";
          var fs = new FileStream(name, 
                                  FileMode.Create,
                                  FileAccess.Write);
             Console.WriteLine("Filename: {0}, Encoding: {1}", 
                               name, await FileUtilities.GetEncodingType(fs));
       }
    }
    
    public class FileUtilities
    {
       public enum EncodingType
       { None = 0, Unknown = -1, Utf8 = 1, Utf16 = 2, Utf32 = 3 }
       
       public async static Task<EncodingType> GetEncodingType(FileStream fs)
       {
          Byte[] bytes = new Byte[4];
          int bytesRead = await fs.ReadAsync(bytes, 0, 4);
          if (bytesRead < 2)
             return EncodingType.None;
          
          if (bytesRead >= 3 & (bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF))
             return EncodingType.Utf8;
          
          if (bytesRead == 4) { 
             var value = BitConverter.ToUInt32(bytes, 0);
             if (value == 0x0000FEFF | value == 0xFEFF0000)
                return EncodingType.Utf32;
          }
          
          var value16 = BitConverter.ToUInt16(bytes, 0);
          if (value16 == (ushort)0xFEFF | value16 == (ushort)0xFFFE) 
             return EncodingType.Utf16;
          
          return EncodingType.Unknown;
       }
    }
    // The example displays the following output:
    //    Unhandled Exception: System.NotSupportedException: Stream does not support reading.
    //       at System.IO.FileStream.BeginRead(Byte[] array, Int32 offset, Int32 numBytes, AsyncCallback callback, Object state)
    //       at System.IO.Stream.<>c.<BeginEndReadAsync>b__46_0(Stream stream, ReadWriteParameters args, AsyncCallback callback, Object state)
    //       at System.Threading.Tasks.TaskFactory`1.FromAsyncTrim[TInstance, TArgs](TInstance thisRef, TArgs args, Func`5 beginMethod, Func`3 endMethod)
    //       at System.IO.Stream.BeginEndReadAsync(Byte[] buffer, Int32 offset, Int32 count)
    //       at System.IO.FileStream.ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
    //       at System.IO.Stream.ReadAsync(Byte[] buffer, Int32 offset, Int32 count)
    //       at FileUtilities.GetEncodingType(FileStream fs) in C:\Work\docs\program.cs:line 26
    //       at Example.Main() in C:\Work\docs\program.cs:line 13
    //       at Example.<Main>()
    
    Imports System.IO
    Imports System.Threading.Tasks
    
    Module Example
       Public Sub Main()
          Dim name As String = ".\TestFile.dat"
          Dim fs As New FileStream(name, 
                                   FileMode.Create,
                                   FileAccess.Write)
          Console.WriteLine("Filename: {0}, Encoding: {1}", 
                            name, FileUtilities.GetEncodingType(fs))
       End Sub
    End Module
    
    Public Class FileUtilities
       Public Enum EncodingType As Integer
          None = 0
          Unknown = -1
          Utf8 = 1
          Utf16 = 2
          Utf32 = 3
       End Enum
       
       Public Shared Function GetEncodingType(fs As FileStream) As EncodingType
          Dim bytes(3) As Byte
          Dim t As Task(Of Integer) = fs.ReadAsync(bytes, 0, 4)
          t.Wait()
          Dim bytesRead As Integer = t.Result
          If bytesRead < 2 Then Return EncodingType.None
          
          If bytesRead >= 3 And (bytes(0) = &hEF AndAlso bytes(1) = &hBB AndAlso bytes(2) = &hBF) Then
             Return EncodingType.Utf8
          End If
          
          If bytesRead = 4 Then 
             Dim value As UInteger = BitConverter.ToUInt32(bytes, 0)
             If value = &h0000FEFF Or value = &hFEFF0000 Then
                Return EncodingType.Utf32
             End If
          End If
          
          Dim value16 As UInt16 = BitConverter.ToUInt16(bytes, 0)
          If value16 = &hFEFF Or value16 = &hFFFE Then 
             Return EncodingType.Utf16
          End If
          
          Return EncodingType.Unknown
       End Function
    End Class
    ' The example displays the following output:
    '    Unhandled Exception: System.NotSupportedException: Stream does not support reading.
    '       at System.IO.Stream.BeginReadInternal(Byte[] buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state,
    '     Boolean serializeAsynchronously)
    '       at System.IO.FileStream.BeginRead(Byte[] array, Int32 offset, Int32 numBytes, AsyncCallback userCallback, Object stat
    '    eObject)
    '       at System.IO.Stream.<>c.<BeginEndReadAsync>b__43_0(Stream stream, ReadWriteParameters args, AsyncCallback callback, O
    '    bject state)
    '       at System.Threading.Tasks.TaskFactory`1.FromAsyncTrim[TInstance,TArgs](TInstance thisRef, TArgs args, Func`5 beginMet
    '    hod, Func`3 endMethod)
    '       at System.IO.Stream.BeginEndReadAsync(Byte[] buffer, Int32 offset, Int32 count)
    '       at System.IO.FileStream.ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
    '       at System.IO.Stream.ReadAsync(Byte[] buffer, Int32 offset, Int32 count)
    '       at FileUtilities.GetEncodingType(FileStream fs)
    '       at Example.Main()
    

    Sie können die Ausnahme eliminieren, indem Sie den Wert der FileStream.CanRead -Eigenschaft untersuchen und die-Methode beenden, wenn der Stream schreibgeschützt ist.You can eliminate the exception by examining the value of the FileStream.CanRead property and exiting the method if the stream is read-only.

       public static async Task<EncodingType> GetEncodingType(FileStream fs)
       {
          if (!fs.CanRead) 
             return EncodingType.Unknown;
    
          Byte[] bytes = new Byte[4];
          int bytesRead = await fs.ReadAsync(bytes, 0, 4);
          if (bytesRead < 2)
             return EncodingType.None;
          
          if (bytesRead >= 3 & (bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF))
             return EncodingType.Utf8;
          
          if (bytesRead == 4) { 
             var value = BitConverter.ToUInt32(bytes, 0);
             if (value == 0x0000FEFF | value == 0xFEFF0000)
                return EncodingType.Utf32;
          }
          
          var value16 = BitConverter.ToUInt16(bytes, 0);
          if (value16 == (ushort)0xFEFF | value16 == (ushort)0xFFFE) 
             return EncodingType.Utf16;
          
          return EncodingType.Unknown;
       }
    }
    // The example displays the following output:
    //       Filename: .\TestFile.dat, Encoding: Unknown
    
    Public Class FileUtilities
       Public Enum EncodingType As Integer
          None = 0
          Unknown = -1
          Utf8 = 1
          Utf16 = 2
          Utf32 = 3
       End Enum
       
       Public Shared Function GetEncodingType(fs As FileStream) As EncodingType
          If Not fs.CanRead Then
             Return EncodingType.Unknown
    
          Dim bytes(3) As Byte
          Dim t As Task(Of Integer) = fs.ReadAsync(bytes, 0, 4)
          t.Wait()
          Dim bytesRead As Integer = t.Result
          If bytesRead < 2 Then Return EncodingType.None
          
          If bytesRead >= 3 And (bytes(0) = &hEF AndAlso bytes(1) = &hBB AndAlso bytes(2) = &hBF) Then
             Return EncodingType.Utf8
          End If
          
          If bytesRead = 4 Then 
             Dim value As UInteger = BitConverter.ToUInt32(bytes, 0)
             If value = &h0000FEFF Or value = &hFEFF0000 Then
                Return EncodingType.Utf32
             End If
          End If
          
          Dim value16 As UInt16 = BitConverter.ToUInt16(bytes, 0)
          If value16 = &hFEFF Or value16 = &hFFFE Then 
             Return EncodingType.Utf16
          End If
          
          Return EncodingType.Unknown
       End Function
    End Class
    ' The example displays the following output:
    '       Filename: .\TestFile.dat, Encoding: Unknown
    

Die NotSupportedException Ausnahme ist eng mit zwei anderen Ausnahme Typen verknüpft.The NotSupportedException exception is closely related to two other exception types;

NotImplementedException.NotImplementedException.
Diese Ausnahme wird ausgelöst, wenn eine Methode implementiert werden kann, dies aber nicht der Fall ist, weil der Member in einer neueren Version implementiert wird, der Member auf einer bestimmten Plattform nicht verfügbar ist oder der Member zu einer abstrakten Klasse gehört und eine abgeleitete Klasse einen im-Wert bereitstellen muss. die Aufteilung.This exception is thrown when a method could be implemented but is not, either because the member will be implemented in a later version, the member is not available on a particular platform, or the member belongs to an abstract class and a derived class must provide an implementation.

InvalidOperationException
Diese Ausnahme wird in Szenarien ausgelöst, in denen es in der Regel vorkommen kann, dass das-Objekt den angeforderten Vorgang ausführt, und der Objektzustand bestimmt, ob der Vorgang ausgeführt werden kann.This exception is thrown in scenarios in which it is generally sometimes possible for the object to perform the requested operation, and the object state determines whether the operation can be performed.

Anmerkungen zu .NET Compact Framework.NET Compact Framework notes

Wenn Sie mit .NET Compact Framework.NET Compact Framework arbeiten und in einer systemeigenen Funktion P/Invoke verwenden, können folgende Bedingungen zum Auslösen der Ausnahme führen:When working with the .NET Compact Framework.NET Compact Framework and using P/Invoke on a native function, this exception may be thrown if:

  • Die Deklaration im verwalteten Code ist nicht korrekt.The declaration in managed code is incorrect.

  • Ihre Aktion wird nicht von .NET Compact Framework.NET Compact Framework unterstützt.The .NET Compact Framework.NET Compact Framework does not support what you are trying to do.

  • Die DLL-Namen werden beim Export geändert.The DLL names are mangled on export.

Wenn eine NotSupportedException -Ausnahme ausgelöst wird, überprüfen Sie Folgendes:If a NotSupportedException exception is thrown, check:

  • Ob Verstöße gegen die P/Invoke-Beschränkungen von .NET Compact Framework.NET Compact Framework vorliegen.For any violations of the .NET Compact Framework.NET Compact Framework P/Invoke restrictions.

  • Ob Argumente vorhanden sind, die im Voraus belegten Arbeitsspeicher erfordern.For any arguments that require pre-allocated memory. Falls sie vorhanden sind, sollten Sie einen Verweis auf eine vorhandene Variable übergeben.If these exist, you should pass a reference to an existing variable.

  • Ob die Namen der exportierten Funktionen korrekt sind.That the names of the exported functions are correct. Dies kann mit DUMPBIN. exeüberprüft werden.This can be verified with DumpBin.exe.

  • Ob Sie zu viele Argumente zu übergeben versuchen.That you are not attempting to pass too many arguments.

Konstruktoren

NotSupportedException()

Initialisiert eine neue Instanz der NotSupportedException-Klasse. Dabei wird die Message-Eigenschaft der neuen Instanz auf eine vom System gelieferte Meldung festgelegt, die den Fehler beschreibt.Initializes a new instance of the NotSupportedException class, setting the Message property of the new instance to a system-supplied message that describes the error. Diese Meldung berücksichtigt die aktuelle Systemkultur.This message takes into account the current system culture.

NotSupportedException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der NotSupportedException-Klasse mit serialisierten Daten.Initializes a new instance of the NotSupportedException class with serialized data.

NotSupportedException(String)

Initialisiert eine neue Instanz der NotSupportedException-Klasse mit einer angegebenen Fehlermeldung.Initializes a new instance of the NotSupportedException class with a specified error message.

NotSupportedException(String, Exception)

Initialisiert eine neue Instanz der NotSupportedException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.Initializes a new instance of the NotSupportedException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Eigenschaften

Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Geerbt von Exception)
HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.Gets or sets a link to the help file associated with this exception.

(Geerbt von Exception)
HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Geerbt von Exception)
InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.Gets the Exception instance that caused the current exception.

(Geerbt von Exception)
Message

Ruft eine Meldung ab, die die aktuelle Ausnahme beschreibt.Gets a message that describes the current exception.

(Geerbt von Exception)
Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.Gets or sets the name of the application or the object that causes the error.

(Geerbt von Exception)
StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.Gets a string representation of the immediate frames on the call stack.

(Geerbt von Exception)
TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.Gets the method that throws the current exception.

(Geerbt von Exception)

Methoden

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Geerbt von Exception)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Geerbt von Exception)
GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.Gets the runtime type of the current instance.

(Geerbt von Exception)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.Creates and returns a string representation of the current exception.

(Geerbt von Exception)

Ereignisse

SerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Geerbt von Exception)

Gilt für:

Siehe auch