NotSupportedException Klas

Definitie

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

Overname

Object

Exception

NotSupportedException

Overname

Object

Exception

SystemException

NotSupportedException

Afgeleid

System.PlatformNotSupportedException

Kenmerken

SerializableAttribute ComVisibleAttribute

Opmerkingen

NotSupportedException geeft aan dat er geen implementatie bestaat voor een aangeroepen methode of eigenschap.

NotSupportedException maakt gebruik van HRESULT COR_E_NOTSUPPORTED, met de waarde 0x80131515.

Voor een lijst van initiële eigenschapswaarden voor een exemplaar van NotSupportedException, zie de NotSupportedException-constructoren.

Een NotSupportedException-uitzondering genereren

U kunt overwegen om in de volgende gevallen een NotSupportedException uitzondering te genereren:

• U implementeert een interface voor algemeen gebruik en sommige methoden hebben geen zinvolle implementatie. Als u bijvoorbeeld een datum- en tijdtype maakt dat de IConvertible interface implementeert, genereert u een NotSupportedException uitzondering voor de meeste conversies.

• U hebt overgenomen van een abstracte klasse waarvoor u bepaalde methoden moet overschrijven. U bent echter alleen bereid om een implementatie te bieden voor een subset hiervan. Voor de methoden die u besluit niet te implementeren, kunt u kiezen om een NotSupportedException te gooien.

• U definieert een type algemeen gebruik met een status waarmee bewerkingen voorwaardelijk worden ingeschakeld. Uw type kan bijvoorbeeld alleen-lezen of lezen-schrijven zijn. In dit geval:

  • Als het object het kenmerk Alleen-lezen heeft, moet een uitzondering worden gegenereerd NotSupportedException wanneer u probeert waarden toe te wijzen aan de eigenschappen van een exemplaar of methoden aanroept waarmee de instantiestatus wordt gewijzigd.

  • U moet een eigenschap implementeren die een Boolean waarde retourneert die aangeeft of bepaalde functionaliteit beschikbaar is. Voor een type dat alleen-lezen of lezen-schrijven kan zijn, kunt u bijvoorbeeld een IsReadOnly eigenschap implementeren die aangeeft of de set lees-/schrijfmethoden beschikbaar of niet beschikbaar is.

Een NotSupportedException-uitzondering verwerken

De NotSupportedException uitzondering geeft aan dat een methode geen implementatie heeft en dat u deze niet moet aanroepen. U moet de uitzondering niet afhandelen. In plaats daarvan is wat u moet doen afhankelijk van de oorzaak van de uitzondering: of een implementatie volledig afwezig is, of dat de aanroep van het lid niet overeenkomt met het doel van een object (zoals een aanroep van de FileStream.Write methode voor een object met het kenmerk Alleen-lezen FileStream ).

Er is geen implementatie opgegeven omdat de bewerking niet op een zinvolle manier kan worden uitgevoerd. Dit is een veelvoorkomende uitzondering wanneer u methoden aanroept op een object dat implementaties biedt voor de methoden van een abstracte basisklasse of die een interface voor algemeen gebruik implementeert en de methode geen zinvolle implementatie heeft.

De klasse implementeert bijvoorbeeld Convert de IConvertible interface, wat betekent dat het een methode moet bevatten om elk primitief type te converteren naar elk ander primitief type. Veel van deze conversies zijn echter niet mogelijk. Als gevolg hiervan genereert een aanroep naar de Convert.ToBoolean(DateTime) methode bijvoorbeeld een NotSupportedException uitzondering omdat er geen conversie tussen een DateTime en een Boolean waarde mogelijk is.

Als u de uitzondering wilt elimineren, moet u de methode-aanroep elimineren.

De methode-aanroep wordt niet ondersteund op basis van de status van het object. U probeert een lid aan te roepen waarvan de functionaliteit niet beschikbaar is vanwege de status van het object. U kunt de uitzondering op drie manieren elimineren:

• U kent de status van het object van tevoren, maar u hebt een niet-ondersteunde methode of eigenschap aangeroepen. In dit geval is de aanroep van het lid een fout en kunt u deze elimineren.

• U weet de status van het object van tevoren (meestal omdat uw code dit heeft geïnstantieerd), maar het object is onjuist geconfigureerd. In het volgende voorbeeld ziet u dit probleem. Een alleen-lezen FileStream object wordt gemaakt, waarna een poging wordt gedaan om ernaar te schrijven.

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

  U kunt de uitzondering elimineren door ervoor te zorgen dat het geïnstantieerde object de functionaliteit ondersteunt die u van plan bent. In het volgende voorbeeld wordt het probleem van het alleen-lezenobject FileStream opgelost door de juiste argumenten aan de FileStream.FileStream(String, FileMode, FileAccess) constructor op te geven.

• U weet de status van het object niet van tevoren en het object biedt geen ondersteuning voor een bepaalde bewerking. In de meeste gevallen moet het object een eigenschap of methode bevatten die aangeeft of het een bepaalde set bewerkingen ondersteunt. U kunt de uitzondering elimineren door de waarde van het object te controleren en het lid alleen aan te roepen indien van toepassing.

  In het volgende voorbeeld wordt een DetectEncoding methode gedefinieerd waarmee een NotSupportedException uitzondering wordt gegenereerd wanneer deze probeert te lezen vanaf het begin van een stream die geen leestoegang ondersteunt.

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

  U kunt de uitzondering elimineren door de waarde van de FileStream.CanRead eigenschap te controleren en de methode af te sluiten als de stream het kenmerk Alleen-lezen heeft.

      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
  

Verwante uitzonderingstypen

De NotSupportedException uitzondering is nauw verwant aan twee andere uitzonderingstypen:

• NotImplementedException

  Deze uitzondering wordt gegenereerd wanneer een methode kan worden geïmplementeerd, maar niet omdat het lid in een latere versie wordt geïmplementeerd, het lid niet beschikbaar is op een bepaald platform of het lid deel uitmaakt van een abstracte klasse en een afgeleide klasse een implementatie moet bieden.

• InvalidOperationException

  Deze uitzondering wordt opgeworpen in scenario's waarin het object doorgaans in staat kan zijn om de aangevraagde bewerking uit te voeren en de toestand van het object bepaalt of de bewerking kan worden uitgevoerd.

Zie ook

• Exception
• FileStream
• Uitzonderingen verwerken en genereren in .NET