NotSupportedException Classe

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Exception levée quand une méthode appelée n'est pas prise en charge ou pendant une tentative de lecture, recherche ou écriture dans un flux qui ne prend pas en charge la fonctionnalité appelée.

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

Héritage

Object

Exception

NotSupportedException

Héritage

Object

Exception

SystemException

NotSupportedException

Dérivé

System.PlatformNotSupportedException

Attributs

SerializableAttribute ComVisibleAttribute

Remarques

NotSupportedException indique qu’aucune implémentation n’existe pour une méthode ou une propriété appelée.

NotSupportedException utilise le COR_E_NOTSUPPORTED HRESULT, qui a la valeur 0x80131515.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de NotSupportedException, consultez le NotSupportedException constructeurs.

Levée d’une exception NotSupportedException

Vous pouvez envisager de lever une NotSupportedException exception dans les cas suivants :

• Vous implémentez une interface à usage général et le nombre de méthodes n’ont aucune implémentation significative. Par exemple, si vous créez un type de date et d’heure qui implémente l’interface, vous liez une NotSupportedException exception pour la IConvertible plupart des conversions.

• Vous avez hérité d’une classe abstraite qui nécessite que vous substituiez un certain nombre de méthodes. Toutefois, vous êtes prêt à fournir une implémentation pour un sous-ensemble de ces éléments. Pour les méthodes que vous décidez de ne pas implémenter, vous pouvez choisir de lever un NotSupportedException.

• Vous définissez un type à usage général avec un état qui active les opérations de manière conditionnelle. Par exemple, votre type peut être en lecture seule ou en lecture-écriture. Dans ce cas :

  • Si l’objet est en lecture seule, la tentative d’attribuer des valeurs aux propriétés d’une instance ou des méthodes d’appel qui modifient l’état de l’instance doit lever une NotSupportedException exception.

  • Vous devez implémenter une propriété qui retourne une Boolean valeur qui indique si une fonctionnalité particulière est disponible. Par exemple, pour un type qui peut être en lecture seule ou en lecture-écriture, vous pouvez implémenter une IsReadOnly propriété qui indique si l’ensemble de méthodes en lecture-écriture est disponible ou non disponible.

Gestion d’une exception NotSupportedException

L’exception NotSupportedException indique qu’une méthode n’a pas d’implémentation et que vous ne devez pas l’appeler. Vous ne devez pas gérer l’exception. Au lieu de cela, ce que vous devez faire dépend de la cause de l’exception : si une implémentation est complètement absente, ou si l’appel de membre est incohérent avec l’objectif d’un objet (tel qu’un appel à la FileStream.Write méthode sur un objet en lecture seule FileStream .

Une implémentation n’a pas été fournie, car l’opération ne peut pas être effectuée de manière significative.
Il s’agit d’une exception courante lorsque vous appelez des méthodes sur un objet qui fournit des implémentations pour les méthodes d’une classe de base abstraite ou qui implémente une interface à usage général et que la méthode n’a aucune implémentation significative.

Par exemple, la classe implémente l’interface Convert IConvertible , ce qui signifie qu’elle doit inclure une méthode pour convertir chaque type primitif en chaque autre type primitif. Toutefois, la plupart de ces conversions ne sont pas possibles. Par conséquent, un appel à la Convert.ToBoolean(DateTime) méthode, par exemple, lève une NotSupportedException exception, car il n’existe aucune conversion possible entre une DateTime valeur et une Boolean valeur

Pour éliminer l’exception, vous devez éliminer l’appel de méthode.

L’appel de méthode n’est pas pris en charge en fonction de l’état de l’objet.
Vous tentez d’appeler un membre dont la fonctionnalité n’est pas disponible en raison de l’état de l’objet. Vous pouvez éliminer l’exception de l’une des trois façons suivantes :

• Vous connaissez l’état de l’objet à l’avance, mais vous avez appelé une méthode ou une propriété non prise en charge. Dans ce cas, l’appel de membre est une erreur et vous pouvez l’éliminer.

• Vous connaissez l’état de l’objet à l’avance (généralement parce que votre code l’a instancié), mais l’objet est mal configuré. L’exemple suivant illustre ce problème. Il crée un objet en lecture seule FileStream , puis tente d’y écrire.

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

  Vous pouvez éliminer l’exception en garantissant que l’objet instancié prend en charge les fonctionnalités que vous envisagez. L’exemple suivant résout le problème de l’objet en lecture seule FileStream en fournissant les arguments corrects au FileStream.FileStream(String, FileMode, FileAccess) constructeur.

• Vous ne connaissez pas l’état de l’objet à l’avance et l’objet ne prend pas en charge une opération particulière. Dans la plupart des cas, l’objet doit inclure une propriété ou une méthode qui indique s’il prend en charge un ensemble particulier d’opérations. Vous pouvez éliminer l’exception en vérifiant la valeur de l’objet et en appelant le membre uniquement si nécessaire.

  L’exemple suivant définit une DetectEncoding méthode qui lève une NotSupportedException exception lorsqu’elle tente de lire à partir du début d’un flux qui ne prend pas en charge l’accès en lecture.

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

  Vous pouvez éliminer l’exception en examinant la valeur de la FileStream.CanRead propriété et en sortant la méthode si le flux est en lecture seule.

     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
  

Types d’exceptions associés

L’exception NotSupportedException est étroitement liée à deux autres types d’exceptions ;

NotImplementedException.
Cette exception est levée lorsqu’une méthode peut être implémentée, mais n’est pas, car le membre sera implémenté dans une version ultérieure, le membre n’est pas disponible sur une plateforme particulière, ou le membre appartient à une classe abstraite et une classe dérivée doit fournir une implémentation.

InvalidOperationException
Cette exception est levée dans les scénarios dans lesquels il est généralement possible que l’objet effectue l’opération demandée et que l’état de l’objet détermine si l’opération peut être effectuée.

Notes .NET Compact Framework

Lors de l’utilisation du .NET Compact Framework et de l’utilisation de P/Invoke sur une fonction native, cette exception peut être levée si :

• la déclaration dans le code managé est incorrecte ;

• Le .NET Compact Framework ne prend pas en charge ce que vous essayez de faire.

• les noms de DLL sont tronqués lors de l'exportation.

Si une NotSupportedException exception est levée, vérifiez :

• Pour toutes les violations des restrictions .NET Compact Framework P/Invoke.

• Recherchez tous les arguments qui requièrent de la mémoire pré-allouée. Si vous en trouvez, vous devez passer une référence à une variable existante.

• Vérifiez que les noms des fonctions exportées sont corrects. Cela peut être vérifié avec DumpBin.exe.

• Vérifiez que vous n'essayez pas de passer un trop grand nombre d'arguments.

Constructeurs

NotSupportedException()	Initialise une nouvelle instance de la classe NotSupportedException, en affectant un message système décrivant l'erreur à la propriété Message de la nouvelle instance. Ce message prend en compte la culture système en cours.
NotSupportedException(SerializationInfo, StreamingContext)	Initialise une nouvelle instance de la classe NotSupportedException avec des données sérialisées.
NotSupportedException(String)	Initialise une nouvelle instance de la classe NotSupportedException avec un message d'erreur spécifié.
NotSupportedException(String, Exception)	Initialise une nouvelle instance de la classe NotSupportedException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.

Propriétés

Data	Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception. (Hérité de Exception)
HelpLink	Obtient ou définit un lien vers le fichier d'aide associé à cette exception. (Hérité de Exception)
HResult	Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique. (Hérité de Exception)
InnerException	Obtient l'instance Exception qui a provoqué l'exception actuelle. (Hérité de Exception)
Message	Obtient un message qui décrit l'exception active. (Hérité de Exception)
Source	Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur. (Hérité de Exception)
StackTrace	Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels. (Hérité de Exception)
TargetSite	Obtient la méthode qui lève l'exception actuelle. (Hérité de Exception)

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetBaseException()	En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures. (Hérité de Exception)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)	En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception. (Hérité de Exception)
GetType()	Obtient le type au moment de l'exécution de l'instance actuelle. (Hérité de Exception)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Crée et retourne une chaîne représentant l'exception actuelle. (Hérité de Exception)

Événements

SerializeObjectState

Obsolète. Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception. (Hérité de Exception)

Voir aussi

• Exception
• FileStream
• Gestion et levée d’exceptions dans .NET