NotSupportedException Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Eccezione generata quando un metodo richiamato non è supportato oppure quando viene eseguito un tentativo di leggere, eseguire una ricerca, scrivere in un flusso che non supporta la funzionalità richiamata.

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

Ereditarietà

Object

Exception

NotSupportedException

Ereditarietà

Object

Exception

SystemException

NotSupportedException

Derivato

System.PlatformNotSupportedException

Attributi

SerializableAttribute ComVisibleAttribute

Commenti

NotSupportedException indica che nessuna implementazione esiste per un metodo o una proprietà richiamata.

NotSupportedException usa il COR_E_NOTSUPPORTED HRESULT, che ha il valore 0x80131515.

Per un elenco di valori di proprietà iniziali per un'istanza di NotSupportedException, vedere il NotSupportedException costruttori.

Generazione di un'eccezione NotSupportedException

È possibile considerare la generazione di un'eccezione NotSupportedException nei casi seguenti:

• Si implementa un'interfaccia per utilizzo generico e il numero di metodi non ha implementazioni significative. Ad esempio, se si sta creando un tipo di data e ora che implementa l'interfaccia, si genererà un'eccezione NotSupportedException per la IConvertible maggior parte delle conversioni.

• È stata ereditata da una classe astratta che richiede l'override di un numero di metodi. Tuttavia, si è preparati solo a fornire un'implementazione per un subset di questi. Per i metodi che si decide di non implementare, è possibile scegliere di generare un NotSupportedExceptionoggetto .

• Si definisce un tipo per utilizzo generico con uno stato che abilita le operazioni in modo condizionale. Ad esempio, il tipo può essere di sola lettura o scrittura di lettura. In questo caso:

  • Se l'oggetto è di sola lettura, il tentativo di assegnare valori alle proprietà di un'istanza o dei metodi di chiamata che modificano lo stato dell'istanza deve generare un'eccezione NotSupportedException .

  • È necessario implementare una proprietà che restituisce un Boolean valore che indica se è disponibile una determinata funzionalità. Ad esempio, per un tipo che può essere di sola lettura o scrittura di lettura, è possibile implementare una IsReadOnly proprietà che indica se il set di metodi di lettura-scrittura è disponibile o non disponibile.

Gestione di un'eccezione NotSupportedException

L'eccezione NotSupportedException indica che un metodo non ha implementazione e che non è necessario chiamarlo. Non è consigliabile gestire l'eccezione. Ciò che si dovrebbe fare dipende invece dalla causa dell'eccezione: se un'implementazione è completamente assente o la chiamata membro non è coerente con lo scopo di un oggetto , ad esempio una chiamata al FileStream.Write metodo in un oggetto di sola FileStream lettura .

Un'implementazione non è stata fornita perché l'operazione non può essere eseguita in modo significativo.
Si tratta di un'eccezione comune quando si chiamano metodi in un oggetto che fornisce implementazioni per i metodi di una classe base astratta o che implementa un'interfaccia per utilizzo generico e il metodo non ha implementazioni significative.

Ad esempio, la Convert classe implementa l'interfaccia IConvertible , il che significa che deve includere un metodo per convertire ogni tipo primitivo in ogni altro tipo primitivo. Molte di queste conversioni, tuttavia, non sono possibili. Di conseguenza, una chiamata al metodo, ad esempio, genera un'eccezione Convert.ToBoolean(DateTime)NotSupportedException perché non è possibile convertire tra un DateTime e un Boolean valore

Per eliminare l'eccezione, è necessario eliminare la chiamata al metodo.

La chiamata al metodo non è supportata in base allo stato dell'oggetto.
Si sta tentando di richiamare un membro la cui funzionalità non è disponibile a causa dello stato dell'oggetto. È possibile eliminare l'eccezione in uno dei tre modi seguenti:

• Lo stato dell'oggetto è noto in anticipo, ma è stato richiamato un metodo o una proprietà non supportata. In questo caso, la chiamata membro è un errore ed è possibile eliminarla.

• Si conosce lo stato dell'oggetto in anticipo (in genere perché il codice lo ha creato un'istanza), ma l'oggetto non è configurato correttamente. Nell'esempio seguente viene illustrato questo problema. Crea un oggetto di sola FileStream lettura e quindi tenta di scriverlo.

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

  È possibile eliminare l'eccezione assicurandosi che l'oggetto creato supporti la funzionalità desiderata. L'esempio seguente risolve il problema dell'oggetto di sola FileStream lettura fornendo gli argomenti corretti al FileStream.FileStream(String, FileMode, FileAccess) costruttore.

• Non si conosce lo stato dell'oggetto in anticipo e l'oggetto non supporta un'operazione specifica. Nella maggior parte dei casi, l'oggetto deve includere una proprietà o un metodo che indica se supporta un determinato set di operazioni. È possibile eliminare l'eccezione controllando il valore dell'oggetto e richiamando il membro solo se appropriato.

  Nell'esempio seguente viene definito un metodo che genera un'eccezione DetectEncodingNotSupportedException quando tenta di leggere dall'inizio di un flusso che non supporta l'accesso in lettura.

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

  È possibile eliminare l'eccezione esaminando il valore della FileStream.CanRead proprietà e chiudendo il metodo se il flusso è di sola lettura.

     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
  

Tipi di eccezione correlati

L'eccezione NotSupportedException è strettamente correlata a due altri tipi di eccezione;

NotImplementedException.
Questa eccezione viene generata quando un metodo può essere implementato ma non è, perché il membro verrà implementato in una versione successiva, il membro non è disponibile in una determinata piattaforma o il membro appartiene a una classe astratta e una classe derivata deve fornire un'implementazione.

InvalidOperationException
Questa eccezione viene generata negli scenari in cui è in genere possibile che l'oggetto esegua l'operazione richiesta e lo stato dell'oggetto determina se l'operazione può essere eseguita.

Note di .NET Compact Framework

Quando si usa .NET Compact Framework e si usa P/Invoke in una funzione nativa, questa eccezione può essere generata se:

• La dichiarazione nel codice gestito non è corretta.

• .NET Compact Framework non supporta ciò che si sta tentando di eseguire.

• I nomi di DLL vengono modificati durante l'esportazione.

Se viene generata un'eccezione NotSupportedException , controllare:

• Per eventuali violazioni delle restrizioni P/Invoke di .NET Compact Framework.

• Verificare se sono presenti argomenti che richiedono memoria preallocata. In caso affermativo, passare un riferimento a una variabile esistente.

• Verificare che i nomi delle funzioni esportate siano corretti. Questa operazione può essere verificata con DumpBin.exe.

• Verificare che non si stia tentando di passare un numero eccessivo di argomenti.

Costruttori

NotSupportedException()	Inizializza una nuova istanza della classe NotSupportedException, impostando la proprietà Message della nuova istanza su un messaggio fornito dal sistema in cui viene descritto l'errore. Il messaggio prende in considerazione le impostazioni di cultura correnti del sistema.
NotSupportedException(SerializationInfo, StreamingContext)	Inizializza una nuova istanza della classe NotSupportedException con dati serializzati.
NotSupportedException(String)	Inizializza una nuova istanza della classe NotSupportedException con un messaggio di errore specificato.
NotSupportedException(String, Exception)	Inizializza una nuova istanza della classe NotSupportedException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.

Proprietà

Data	Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione. (Ereditato da Exception)
HelpLink	Ottiene o imposta un collegamento al file della Guida associato all'eccezione. (Ereditato da Exception)
HResult	Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica. (Ereditato da Exception)
InnerException	Ottiene l'istanza di Exception che ha causato l'eccezione corrente. (Ereditato da Exception)
Message	Ottiene un messaggio che descrive l'eccezione corrente. (Ereditato da Exception)
Source	Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore. (Ereditato da Exception)
StackTrace	Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate. (Ereditato da Exception)
TargetSite	Ottiene il metodo che genera l'eccezione corrente. (Ereditato da Exception)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetBaseException()	Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive. (Ereditato da Exception)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)	Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione. (Ereditato da Exception)
GetType()	Ottiene il tipo di runtime dell'istanza corrente. (Ereditato da Exception)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Crea e restituisce una rappresentazione di stringa dell'eccezione corrente. (Ereditato da Exception)

Eventi

SerializeObjectState

Obsoleta. Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione. (Ereditato da Exception)

Vedi anche

• Exception
• FileStream
• Gestione e generazione di eccezioni in .NET