NotSupportedException NotSupportedException NotSupportedException NotSupportedException Class

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
NotSupportedExceptionNotSupportedExceptionNotSupportedExceptionNotSupportedException
Abgeleitet
Attribute

Hinweise

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

NotSupportedException verwendet das HRESULT COR_E_NOTSUPPORTED mit dem Wert 0 x 80131515 an.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

Sie sollten erwägen, Auslösen einer NotSupportedException Ausnahme in den folgenden Fällen:You might consider throwing a NotSupportedException exception in the following cases:

  • Sie sind eine allgemeine Schnittstelle implementieren, und die Anzahl der Methoden weisen keine sinnvollen Implementierung.You are implementing a general-purpose interface, and number of the methods have no meaningful implementation. Beispielsweise bei der Erstellung einer Datums- und Uhrzeitangabe geben, implementiert die IConvertible -Schnittstelle, die Sie auslösen würde eine NotSupportedException Ausnahme für die meisten der Konvertierungen.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 außer Kraft setzen.You've inherited from an abstract class that requires that you override a number of methods. Allerdings sind Sie nur darauf vorbereitet, eine Implementierung für eine Teilmenge davon bereitstellen.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 lösen eine NotSupportedException.For the methods that you decide not to implement, you can choose to throw a NotSupportedException.

  • Definieren Sie einen allgemeinen Typ mit dem Status, die Vorgänge bedingt zu ermöglichen.You are defining a general-purpose type with a state that enables operations conditionally. Der Typ kann z. B. schreibgeschützten oder Lese-/ Schreibzugriff sein.For example, your type can be either read-only or read-write. In diesem Fall:In that case:

    • Wenn das Objekt schreibgeschützt ist, versucht, die Werte der Eigenschaften einer Instanz oder rufen Methoden zuweisen, die Zustand der Instanz zu ändern, lösen eine NotSupportedException Ausnahme.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.

    • Sollten Sie eine Eigenschaft, die gibt implementieren eine Boolean Wert, der angibt, ob bestimmte Funktionalität verfügbar ist.You should implement a property that returns a Boolean value that indicates whether particular functionality is available. Z. B. für einen Typ, der schreibgeschützten oder Lese-/ Schreibzugriff möglich, Sie könnten implementieren eine IsReadOnly -Eigenschaft, die angibt, ob der Satz von Lese-/ Schreibzugriff-Methoden sind verfügbar oder nicht verfügbar.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.

Eine NotSupportedException-Ausnahme behandeltHandling a NotSupportedException exception

Die NotSupportedException Ausnahme gibt an, dass eine Methode über keine Implementierung hat und Sie nicht aufrufen sollten.The NotSupportedException exception indicates that a method has no implementation and that you should not call it. Sie sollten die Ausnahme nicht behandelt.You should not handle the exception. Stattdessen, was Sie tun sollten, hängt die Ursache der Ausnahme:, ob eine Implementierung vollständig fehlt oder elementaufrufs inkonsistent Ziel eines Objekts (z. B. durch einen Aufruf der FileStream.Write Methode für eine schreibgeschützte FileStream 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 .

Eine Implementierung wurde nicht angegeben, da der Vorgang kann nicht auf sinnvolle Weise ausgeführt werden.An implementation has not been provided because the operation cannot be performed in a meaningful way.
Dies ist eine allgemeine Ausnahme, wenn Sie die Methode für ein Objekt aufrufen, die Implementierungen für die Methoden von einer abstrakten Klasse oder dieser implementiert eine allgemeine Schnittstelle bereitstellt, und die Methode verfügt über keine sinnvollen Implementierung.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.

Z. B. die Convert -Klasse implementiert die IConvertible Schnittstelle, was bedeutet, dass eine Methode zum Konvertieren von jedem primitiven Typs in allen anderen primitiven Typen enthalten muss.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. Als Ergebnis einen Aufruf der Convert.ToBoolean(DateTime) -Methode, löst eine NotSupportedException Ausnahme da gibt es keine mögliche Konvertierung zwischen einer DateTime und ein Boolean WertAs 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 den Methodenaufruf entfernt werden.To eliminate the exception, you should eliminate the method call.

Der Methodenaufruf wird nicht unterstützt, wenn der Zustand des Objekts.The method call is not supported given the state of the object.
Sie versuchen, einen Member aufzurufen, deren 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 in eine von drei Arten vermeiden:You can eliminate the exception in one of three ways:

  • Der Zustand des Objekts im Voraus wissen, 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 elementaufrufs ist ein Fehler, und Sie können diese entfernen.In this case, the member invocation is an error, and you can eliminate it.

  • Sie kennen den Zustand des Objekts im voraus, (in der Regel, da Ihr Code es instanziiert wurde), aber das Objekt ist nicht korrekt konfiguriert.You know the state of the object in advance (usually because your code has instantiated it), but the object is mis-configured. Das folgende Beispiel veranschaulicht dieses Problem.The following example illustrates this issue. Erstellt eine schreibgeschützte FileStream Objekt und versucht dann, um darin 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, indem Sie sicherstellen vermeiden, die instanziierten Objekts Funktionen unterstützt, die Sie möchten.You can eliminate the exception by ensuring that the instantiated object supports the functionality you intend. Im folgende Beispiel löst das Problem der Read-only FileStream Objekt, indem Sie die richtigen Argumente für die FileStream.FileStream(String, FileMode, FileAccess) Konstruktor.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.

  • Sie wissen nicht, den Zustand des Objekts im voraus, und das Objekt keinen bestimmten Vorgang nicht unterstützt.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 enthalten, einer Eigenschaft oder Methode, der angibt, ob es sich um einen bestimmten Satz von Vorgängen unterstützt.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 vermeiden, indem Sie den Wert des Objekts und Aufruf von der Members, nur bei Bedarf.You can eliminate the exception by checking the value of the object and invoking the member only if appropriate.

    Das folgende Beispiel definiert eine DetectEncoding Methode, die auslöst eine NotSupportedException Ausnahme, wenn versucht wird, ab dem Anfang eines Streams zu lesen, die Lesezugriff nicht 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()
    

    Vermeiden Sie die Ausnahme, durch die Auswertung des Werts für die FileStream.CanRead -Eigenschaft und die Methode wird beendet, 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 andere Ausnahmetypen an;The NotSupportedException exception is closely related to two other exception types;

NotImplementedException.NotImplementedException.
Diese Ausnahme wird ausgelöst, wenn eine Methode implementiert werden kann, aber nicht der Fall, da das Element in einer späteren Version implementiert werden wird, das Element nicht verfügbar, auf einer bestimmten Plattform ist oder der Member zu einer abstrakten Klasse gehört und Sie eine abgeleitete Klasse eine Sofortnachricht geben muss entweder Plementation.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, in denen es im Allgemeinen manchmal möglich, dass das Objekt, das den angeforderten Vorgang auszuführen ist, und der Zustand des Objekts 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 dieser Version .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: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 überprüft werden, mit DumpBin.exe.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() NotSupportedException() NotSupportedException() 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 Methode berücksichtigt die aktuelle Systemkultur.This message takes into account the current system culture.

NotSupportedException(SerializationInfo, StreamingContext) NotSupportedException(SerializationInfo, StreamingContext) NotSupportedException(SerializationInfo, StreamingContext) 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) NotSupportedException(String) NotSupportedException(String) 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) NotSupportedException(String, Exception) NotSupportedException(String, Exception) 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 Data Data 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.

(Inherited from Exception)
HelpLink HelpLink HelpLink 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.

(Inherited from Exception)
HResult HResult HResult 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.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

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

(Inherited from Exception)
Message Message Message Message

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

(Inherited from Exception)
Source Source Source 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.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

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

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

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

(Inherited from Exception)

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() 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.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) 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.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

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

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
ToString() ToString() ToString() ToString()

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

(Inherited from Exception)

Ereignisse

SerializeObjectState SerializeObjectState SerializeObjectState 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.

(Inherited from Exception)

Gilt für:

Siehe auch