NotSupportedException Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

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

Object

Exception

NotSupportedException

Vererbung

Object

Exception

SystemException

NotSupportedException

Abgeleitet

System.PlatformNotSupportedException

Attribute

SerializableAttribute ComVisibleAttribute

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
  

Verwandte Ausnahmetypen

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)

Siehe auch

• Exception
• FileStream
• Behandeln und Auslösen von Ausnahmen in .NET