NotSupportedException Klasse

Definition

Die Ausnahme, die ausgelöst wird, wenn eine aufgerufene Methode nicht unterstützt oder versucht wird, lesend, suchend oder schreibend auf einen Stream zuzugreifen, der die aufgerufene Funktion nicht unterstützt.

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

Hinweise

NotSupportedException gibt an, dass keine Implementierung für eine aufgerufene Methode oder Eigenschaft vorhanden ist.

NotSupportedException verwendet das HRESULT-COR_E_NOTSUPPORTED, das den Wert 0x80131515 hat.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von NotSupportedException, finden Sie unter den NotSupportedException Konstruktoren.

Auslösen einer Ausnahme "NotSupportedException"

Möglicherweise sollten Sie eine NotSupportedException Ausnahme in den folgenden Fällen auslösen:

  • Sie implementieren eine allgemeine Schnittstelle und die Anzahl der Methoden haben keine aussagekräftige Implementierung. Wenn Sie beispielsweise einen Datums- und Uhrzeittyp erstellen, der die Schnittstelle implementiert, würden Sie eine NotSupportedException Ausnahme für die IConvertible meisten Konvertierungen auslösen.

  • Sie haben von einer abstrakten Klasse geerbt, die erfordert, dass Sie eine Reihe von Methoden außer Kraft setzen. Sie sind jedoch nur bereit, eine Implementierung für eine Teilmenge dieser Bereitzustellen. Für die Methoden, die Sie nicht implementieren möchten, können Sie auswählen, dass Sie eine NotSupportedException.

  • Sie definieren einen allgemeinen Typ mit einem Zustand, der Vorgänge bedingt ermöglicht. Ihr Typ kann beispielsweise schreibgeschützt oder schreibgeschützt sein. Dabei trifft Folgendes zu:

    • Wenn das Objekt schreibgeschützt ist, sollten Sie versuchen, Den Eigenschaften einer Instanz oder einer Aufrufmethode, die den Instanzstatus ändern, eine NotSupportedException Ausnahme zuzuweisen.

    • Sie sollten eine Eigenschaft implementieren, die einen Boolean Wert zurückgibt, der angibt, ob bestimmte Funktionen verfügbar sind. Beispielsweise können Sie für einen Typ, der schreibgeschützt oder schreibgeschützt sein kann, eine IsReadOnly Eigenschaft implementieren, die angibt, ob der Satz von Lesezugriffsmethoden verfügbar oder nicht verfügbar ist.

Behandeln einer Ausnahme von NotSupportedException

Die NotSupportedException Ausnahme gibt an, dass eine Methode keine Implementierung aufweist und sie nicht aufrufen sollte. Sie sollten die Ausnahme nicht behandeln. Stattdessen hängt es von der Ursache der Ausnahme ab: Ob eine Implementierung vollständig nicht vorhanden ist, oder die Memberanrufung ist mit dem Zweck eines Objekts inkonsistent (z. B. ein Aufruf der FileStream.Write Methode auf einem schreibgeschützten FileStream Objekt).

Eine Implementierung wurde nicht bereitgestellt, da der Vorgang nicht auf sinnvolle Weise ausgeführt werden kann.
Dies ist eine häufige Ausnahme, wenn Sie Methoden für ein Objekt aufrufen, die Implementierungen für die Methoden einer abstrakten Basisklasse bereitstellt oder eine allgemeine Schnittstelle implementiert, und die Methode hat keine aussagekräftige Implementierung.

Die Klasse implementiert beispielsweise Convert die IConvertible Schnittstelle, was bedeutet, dass sie eine Methode enthalten muss, um jeden Grundtyp in jeden anderen Grundtyp zu konvertieren. Viele dieser Konvertierungen sind jedoch nicht möglich. Daher löst ein Aufruf der Convert.ToBoolean(DateTime) Methode beispielsweise eine NotSupportedException Ausnahme aus, da keine Konvertierung zwischen einem DateTime und einem Boolean Wert möglich ist.

Um die Ausnahme zu beseitigen, sollten Sie den Methodenaufruf entfernen.

Der Methodenaufruf wird aufgrund des Zustands des Objekts nicht unterstützt.
Sie versuchen, ein Element aufzurufen, dessen Funktionalität aufgrund des Zustands des Objekts nicht verfügbar ist. Sie können die Ausnahme auf eine von drei Arten entfernen:

  • Sie kennen den Status des Objekts im Voraus, aber Sie haben eine nicht unterstützte Methode oder Eigenschaft aufgerufen. In diesem Fall ist der Aufruf des Mitglieds ein Fehler, und Sie können es entfernen.

  • Sie wissen den Status des Objekts im Voraus (normalerweise weil Ihr Code es instanziiert hat), aber das Objekt ist falsch konfiguriert. Im folgenden Beispiel wird dieses Problem veranschaulicht. Es erstellt ein schreibgeschütztes FileStream Objekt und versucht dann, darauf zu schreiben.

    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()
    
    open System.IO
    open System.Text
    
    let main = task {
        let enc = Encoding.Unicode
        let value = "This is a string to persist."
        let bytes  = enc.GetBytes value
    
        let fs = new FileStream(@".\TestFile.dat", FileMode.Open, FileAccess.Read)
        let t = fs.WriteAsync(enc.GetPreamble(), 0, enc.GetPreamble().Length)
        let t2 = t.ContinueWith(fun a -> fs.WriteAsync(bytes, 0, bytes.Length))
        let! _ = t2
        fs.Close()
    }
    main.Wait()
    
    // 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 <StartupCode:fs>.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 beseitigen, indem Sie sicherstellen, dass das instanziierte Objekt die gewünschte Funktionalität unterstützt. 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.

  • Sie kennen den Zustand des Objekts im Voraus nicht, und das Objekt unterstützt keinen bestimmten Vorgang. In den meisten Fällen sollte das Objekt eine Eigenschaft oder Methode enthalten, die angibt, ob eine bestimmte Gruppe von Vorgängen unterstützt wird. Sie können die Ausnahme entfernen, indem Sie den Wert des Objekts überprüfen und das Element nur bei Bedarf aufrufen.

    Im folgenden Beispiel wird eine Methode definiert, die eine DetectEncoding NotSupportedException Ausnahme auslöst, wenn es versucht, vom Anfang eines Datenstroms zu lesen, der den Lesezugriff nicht unterstützt.

    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>()
    
    open System
    open System.IO
    
    module FileUtilities =
        type EncodingType =
            | None = 0
            | Unknown = -1
            | Utf8 = 1
            | Utf16 = 2
            | Utf32 = 3
    
        let getEncodingType (fs: FileStream) = 
            task {
                let bytes = Array.zeroCreate<byte> 4
                let! bytesRead = fs.ReadAsync(bytes, 0, 4)
                if bytesRead < 2 then
                    return EncodingType.None
    
                elif bytesRead >= 3 && bytes[0] = 0xEFuy && bytes[1] = 0xBBuy && bytes[2] = 0xBFuy then
                    return EncodingType.Utf8
                else
                    let value = BitConverter.ToUInt32(bytes, 0)
                    if bytesRead = 4 && (value = 0x0000FEFFu || value = 0xFEFF0000u) then
                        return EncodingType.Utf32
                    else
                        let value16 = BitConverter.ToUInt16(bytes, 0)
                        if value16 = 0xFEFFus || value16 = 0xFFFEus then
                            return EncodingType.Utf16
                        else
                            return EncodingType.Unknown
            }
    
    let main _ = 
        task {
            let name = @".\TestFile.dat"
            let fs = new FileStream(name, FileMode.Create, FileAccess.Write)
            let! et = FileUtilities.getEncodingType fs
            printfn $"Filename: {name}, Encoding: {et}"
        }
    
    // 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)
    //       at Example.Main()
    //       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 entfernen, indem Sie den Wert der FileStream.CanRead Eigenschaft untersuchen und die Methode beenden, wenn der Stream schreibgeschützt ist.

       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
    
    let getEncodingType (fs: FileStream) = 
        task {
            if not fs.CanRead then
                return EncodingType.Unknown
            else
                let bytes = Array.zeroCreate<byte> 4
                let! bytesRead = fs.ReadAsync(bytes, 0, 4)
                if bytesRead < 2 then
                    return EncodingType.None
    
                elif bytesRead >= 3 && bytes[0] = 0xEFuy && bytes[1] = 0xBBuy && bytes[2] = 0xBFuy then
                    return EncodingType.Utf8
                else
                    let value = BitConverter.ToUInt32(bytes, 0)
                    if bytesRead = 4 && (value = 0x0000FEFFu || value = 0xFEFF0000u) then
                        return EncodingType.Utf32
                    else
                        let value16 = BitConverter.ToUInt16(bytes, 0)
                        if value16 = 0xFEFFus || value16 = 0xFFFEus then
                            return EncodingType.Utf16
                        else
                            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 Ausnahmetypen verknüpft;

NotImplementedException.
Diese Ausnahme wird ausgelöst, wenn eine Methode implementiert werden könnte, aber nicht, entweder weil das Element in einer späteren Version implementiert wird, ist das Element nicht auf einer bestimmten Plattform verfügbar, oder das Element gehört zu einer abstrakten Klasse und eine abgeleitete Klasse muss eine Implementierung bereitstellen.

InvalidOperationException
Diese Ausnahme wird in Szenarien ausgelöst, in denen es in der Regel für das Objekt möglich ist, den angeforderten Vorgang auszuführen, und der Objektzustand bestimmt, ob der Vorgang ausgeführt werden kann.

.NET Compact Framework-Notizen

Wenn Sie mit .NET Compact Framework arbeiten und P/Aufruf auf einer systemeigenen Funktion verwenden, kann diese Ausnahme ausgelöst werden, wenn:

  • Die Deklaration im verwalteten Code ist nicht korrekt.

  • Das .NET Compact Framework unterstützt nicht, was Sie tun möchten.

  • Die DLL-Namen werden beim Export geändert.

Wenn eine NotSupportedException Ausnahme ausgelöst wird, überprüfen Sie:

  • Für alle Verletzungen der .NET Compact Framework P/Invoke-Einschränkungen.

  • Ob Argumente vorhanden sind, die im Voraus belegten Arbeitsspeicher erfordern. Falls sie vorhanden sind, sollten Sie einen Verweis auf eine vorhandene Variable übergeben.

  • Ob die Namen der exportierten Funktionen korrekt sind. Dies kann mit DumpBin.exeüberprüft werden.

  • Ob Sie zu viele Argumente zu übergeben versuchen.

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. Diese Meldung berücksichtigt die aktuelle Systemkultur.

NotSupportedException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der NotSupportedException-Klasse mit serialisierten Daten.

NotSupportedException(String)

Initialisiert eine neue Instanz der NotSupportedException-Klasse mit einer angegebenen Fehlermeldung.

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.

Eigenschaften

Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen.

(Geerbt von Exception)
HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.

(Geerbt von Exception)
HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.

(Geerbt von Exception)
InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.

(Geerbt von Exception)
Message

Ruft eine Meldung ab, mit der die aktuelle Ausnahme beschrieben wird.

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

(Geerbt von Exception)
StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.

(Geerbt von Exception)
TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.

(Geerbt von Exception)

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist.

(Geerbt von Exception)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.

(Geerbt von Exception)
GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.

(Geerbt von Exception)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.

(Geerbt von Exception)

Ereignisse

SerializeObjectState
Veraltet.

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.

(Geerbt von Exception)

Gilt für:

Siehe auch