NotSupportedException Klasse

Definition

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 für eine aufgerufene Methode oder Eigenschaft keine Implementierung 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 NotSupportedException-Ausnahme

In den folgenden Fällen sollten Sie eine NotSupportedException Exception auslösen:

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

• Sie haben von einer abstrakten Klasse geerbt, die erfordert, dass Sie einige Methoden überschreiben. Sie sind jedoch nur bereit, eine Implementierung für eine Teilmenge davon anzubieten. Für die Methoden, die Sie nicht implementieren möchten, können Sie eine NotSupportedException-Ausnahme auslösen.

• Sie definieren einen allgemeinen Typ mit einem Zustand, der Vorgänge bedingt ermöglicht. Ihr Typ kann beispielsweise schreibgeschützt oder les- und schreibbar sein. In diesem Fall:

  • Eine NotSupportedException-Ausnahme sollte für schreibgeschützte Objekte beim Versuch ausgelöst werden, den Eigenschaften einer Instanz oder Methoden, die den Status der Instanz ändern, Werte zuzuweisen.

  • Sie sollten eine Eigenschaft implementieren, die einen Boolean Wert zurückgibt, der angibt, ob bestimmte Funktionen verfügbar sind. Beispielsweise könnten Sie für einen Typ, der schreibgeschützt oder les- und schreibbar sein kann, eine IsReadOnly-Eigenschaft implementieren, die angibt, ob die Lese-/Schreibmethoden verfügbar sind.

Behandeln einer NotSupportedException-Ausnahme

Die NotSupportedException Ausnahme gibt an, dass eine Methode keine Implementierung aufweist und dass Sie sie nicht aufrufen sollten. Sie sollten die Ausnahme nicht behandeln. Was Sie stattdessen tun sollten, hängt von der Ursache der Ausnahme ab: ob eine Implementierung vollständig nicht vorhanden ist oder der Memberaufruf mit dem Zweck eines Objekts inkonsistent ist (z. B. ein Aufruf der FileStream.Write Methode für ein schreibgeschütztes FileStream Objekt).

Eine Implementierung wurde nicht bereitgestellt, da der Vorgang nicht sinnvoll ausgeführt werden kann. 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 hat keine sinnvolle Implementierung.

Beispielsweise implementiert die Convert Klasse 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 beseitigen.

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

• 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 ihn beseitigen.

• Sie kennen den Status des Objekts im Voraus (in der Regel weil ihr Code es instanziiert hat), aber das Objekt ist falsch konfiguriert. Das folgende Beispiel veranschaulicht dieses Problem. Es erstellt ein schreibgeschütztes FileStream Objekt und versucht dann, in das Objekt 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 dem Konstruktor die richtigen Argumente FileStream.FileStream(String, FileMode, FileAccess) bereitgestellt werden.

• Sie kennen den Status 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 es eine bestimmte Gruppe von Vorgängen unterstützt. Sie können die Ausnahme beseitigen, indem Sie den Wert des Objekts überprüfen und das Element nur bei Bedarf aufrufen.

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

  using System;
  using System.IO;
  using System.Threading.Tasks;
  
  public class TestPropEx1
  {
      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 FileUtilities1.GetEncodingType(fs));
      }
  }
  
  public class FileUtilities1
  {
      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 Example2
      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, FileUtilities2.GetEncodingType(fs))
      End Sub
  End Module
  
  Public Class FileUtilities2
      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 = &HFEFF 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 FileUtilities2.GetEncodingType(FileStream fs)
  '       at Example.Main()
  

  Sie können die Ausnahme vermeiden, indem Sie den Wert der FileStream.CanRead-Eigenschaft untersuchen und die Methode beenden, wenn der Datenstrom 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 FileUtilities3
      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
          End If
  
          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 = &HFEFF 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 hängt eng mit zwei anderen Ausnahmetypen zusammen:

• NotImplementedException

  Diese Ausnahme wird ausgelöst, wenn eine Methode implementiert werden kann, aber nicht, entweder weil das Element in einer späteren Version implementiert wird, das Mitglied ist nicht auf einer bestimmten Plattform verfügbar, oder der Member 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 möglich ist, dass das Objekt den angeforderten Vorgang ausführt, und der Objektstatus bestimmt, ob der Vorgang ausgeführt werden kann.

Weitere Informationen

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