NotSupportedException Clase

Definición

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

Herencia

Object

Exception

NotSupportedException

Herencia

Object

Exception

SystemException

NotSupportedException

Derivado

System.PlatformNotSupportedException

Atributos

SerializableAttribute ComVisibleAttribute

Comentarios

NotSupportedException indica que no existe ninguna implementación para un método o propiedad invocados.

NotSupportedException usa HRESULT COR_E_NOTSUPPORTED, que tiene el valor 0x80131515.

Para obtener una lista de valores de propiedad iniciales para una instancia de NotSupportedException, vea los NotSupportedException constructores.

Inicio de una excepción NotSupportedException

Es posible que considere la posibilidad de producir una excepción NotSupportedException en los casos siguientes:

• Está implementando una interfaz de uso general y algunos de los métodos no tienen ninguna implementación significativa. Por ejemplo, si va a crear un tipo de fecha y hora que implemente la IConvertible interfaz, producirá una NotSupportedException excepción para la mayoría de las conversiones.

• Ha heredado de una clase abstracta que requiere que invalide algunos métodos. Sin embargo, solo está preparado para proporcionar una implementación para un subconjunto de estos. Para los métodos que decida no implementar, puede elegir iniciar un NotSupportedException.

• Va a definir un tipo de uso general con un estado que habilita las operaciones condicionalmente. Por ejemplo, el tipo puede ser de solo lectura o de lectura y escritura. En ese caso:

  • Si el objeto es de solo lectura, al intentar asignar valores a las propiedades de una instancia o llamar a métodos que modifiquen el estado de instancia, se producirá una NotSupportedException excepción.

  • Debe implementar una propiedad que devuelva un Boolean valor que indique si hay alguna funcionalidad disponible. Por ejemplo, para un tipo que puede ser de solo lectura o de lectura y escritura, podría implementar una propiedad IsReadOnly que indique si el conjunto de métodos de lectura y escritura están disponibles o no disponibles.

Control de una excepción NotSupportedException

La NotSupportedException excepción indica que un método no tiene ninguna implementación y que no debe llamarlo. No debe controlar la excepción. En su lugar, lo que debe hacer depende de la causa de la excepción: ya sea porque una implementación está completamente ausente o porque la invocación del miembro es incoherente con el objetivo del objeto (como una llamada al método FileStream.Write en un objeto FileStream de solo lectura).

No se ha proporcionado una implementación porque la operación no se puede realizar de forma significativa. Se trata de una excepción común cuando se llama a métodos en un objeto que proporciona implementaciones para los métodos de una clase base abstracta, o que implementa una interfaz de uso general y el método no tiene ninguna implementación significativa.

Por ejemplo, la Convert clase implementa la IConvertible interfaz , lo que significa que debe incluir un método para convertir todos los tipos primitivos en todos los demás tipos primitivos. Sin embargo, muchas de esas conversiones no son posibles. Como resultado, una llamada al Convert.ToBoolean(DateTime) método, por ejemplo, produce una NotSupportedException excepción porque no hay ninguna conversión posible entre un DateTime valor y .Boolean

Para eliminar la excepción, debe eliminar la llamada al método.

La llamada al método no se admite debido al estado del objeto. Está intentando invocar un miembro cuya funcionalidad no está disponible debido al estado del objeto. Puede eliminar la excepción de una de estas tres maneras:

• Conoce el estado del objeto de antemano, pero ha invocado un método o propiedad no admitidos. En este caso, la invocación de miembro es un error y puede eliminarla.

• Conoce el estado del objeto de antemano (normalmente porque el código lo ha creado), pero el objeto está mal configurado. En el ejemplo siguiente se muestra este problema. Crea un objeto FileStream de solo lectura y luego intenta escribir en él.

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

  Puede eliminar la excepción asegurándose de que el objeto creado por instancias admite la funcionalidad que pretende. En el ejemplo siguiente se soluciona el problema del objeto de solo lectura FileStream proporcionando los argumentos correctos al constructor FileStream.FileStream(String, FileMode, FileAccess).

• No conoce el estado del objeto de antemano y el objeto no admite una operación determinada. En la mayoría de los casos, el objeto debe incluir una propiedad o un método que indique si admite un conjunto determinado de operaciones. Puede eliminar la excepción comprobando el valor del objeto e invocando el miembro solo si procede.

  En el ejemplo siguiente se define un DetectEncoding método que lanza una NotSupportedException excepción al intentar leer desde el principio de una secuencia que no admite el acceso de lectura.

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

  Puede eliminar la excepción examinando el valor de la propiedad FileStream.CanRead y salir del método si el flujo es de solo lectura.

      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
  

Tipos de excepciones relacionados

La NotSupportedException excepción está estrechamente relacionada con otros dos tipos de excepciones:

• NotImplementedException

  Esta excepción se produce cuando se puede implementar un método, pero no es así, ya sea porque el miembro se implementará en una versión posterior, el miembro no está disponible en una plataforma determinada o el miembro pertenece a una clase abstracta y una clase derivada debe proporcionar una implementación.

• InvalidOperationException

  Esta excepción se produce en escenarios en los que, por lo general, es posible que el objeto realice la operación solicitada y el estado del objeto determina si se puede realizar la operación.

Consulte también

• Exception
• FileStream
• Controlar y generar excepciones en .NET