Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe NotSupportedException

 

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.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Exception
    System.SystemException
      System.NotSupportedException
        System.PlatformNotSupportedException

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class NotSupportedException : SystemException

NomeDescrizione
System_CAPS_pubmethodNotSupportedException()

Inizializza una nuova istanza di NotSupportedException classe, impostando il Message proprietà della nuova istanza di un messaggio fornito dal sistema che descrive l'errore. Questo messaggio prende in considerazione le impostazioni cultura correnti del sistema.

System_CAPS_protmethodNotSupportedException(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe NotSupportedException con dati serializzati.

System_CAPS_pubmethodNotSupportedException(String)

Inizializza una nuova istanza della classe NotSupportedException con un messaggio di errore specificato.

System_CAPS_pubmethodNotSupportedException(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.

NomeDescrizione
System_CAPS_pubpropertyData

Ottiene una collezione di coppie chiave/valore che forniscono ulteriori informazioni definite dall'utente sull'eccezione. (Ereditato da Exception.)

System_CAPS_pubpropertyHelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.(Ereditato da Exception.)

System_CAPS_pubpropertyHResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato ad una specifica eccezione. (Ereditato da Exception.)

System_CAPS_pubpropertyInnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.(Ereditato da Exception.)

System_CAPS_pubpropertyMessage

Ottiene un messaggio che descrive l'eccezione corrente.(Ereditato da Exception.)

System_CAPS_pubpropertySource

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.(Ereditato da Exception.)

System_CAPS_pubpropertyStackTrace

Ottiene una rappresentazione in forma di stringa dei frame nello stack di chiamate. (Ereditato da Exception.)

System_CAPS_pubpropertyTargetSite

Ottiene il metodo che ha generato l'eccezione corrente. (Ereditato da Exception.)

NomeDescrizione
System_CAPS_pubmethodEquals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object.)

System_CAPS_protmethodFinalize()

Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object.)

System_CAPS_pubmethodGetBaseException()

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

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione.(Ereditato da Exception.)

System_CAPS_pubmethodGetType()

Ottiene il tipo di runtime dell'istanza corrente.(Ereditato da Exception.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_pubmethodToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.(Ereditato da Exception.)

NomeDescrizione
System_CAPS_proteventSerializeObjectState

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

NotSupportedException indica l'esistenza di alcuna implementazione per una proprietà o metodo richiamato.

NotSupportedException utilizza HRESULT COR_E_NOTSUPPORTED, con valore 0x80131515.

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

È possibile generare un NotSupportedException eccezione nei casi seguenti:

  • Implementazione di un'interfaccia di uso generale e alcuni metodi di non avere alcuna implementazione significativa. Ad esempio, se si sta creando una data e ora il tipo che implementa il IConvertible interfaccia, è necessario generare un NotSupportedException eccezione per la maggior parte delle conversioni.

  • È stata ereditata da una classe astratta che è necessario eseguire l'override di un numero di metodi. Tuttavia, solo è in grado di fornire un'implementazione per un sottoinsieme di questi. Per i metodi che si decide di non implementare, è possibile scegliere di generare un NotSupportedException.

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

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

    • È necessario implementare una proprietà che restituisce un Boolean valore che indica se è disponibile una funzionalità specifica. Per un tipo che può essere di sola lettura o lettura / scrittura, ad esempio, è possibile implementare un IsReadOnly proprietà che indica se il set di metodi di lettura / scrittura sono disponibili o non disponibile.

Il NotSupportedException eccezione indica che un metodo non dispone di implementazione e non è necessario chiamare il. Non è necessario gestire l'eccezione. Al contrario, le operazioni da eseguire dipende dalla causa dell'eccezione: se un'implementazione è completamente assente o la chiamata al membro non è coerente con lo scopo di un oggetto (ad esempio una chiamata al FileStream.Read metodo in sola lettura FileStream oggetto.

Non è stata specificata un'implementazione perché l'operazione non può essere eseguita in modo significativo.

Si tratta di un'eccezione comune quando si chiama metodi su un oggetto che fornisce le implementazioni per i metodi della classe base astratta o che implementa un'interfaccia generica e il metodo non ha un'implementazione significativa.

Ad esempio, la Convert classe implementa il IConvertible interfaccia, il che significa che deve includere un metodo per convertire tutti i tipi primitivi in tutti gli altri tipi primitivi. Molte di tali conversioni, tuttavia, non sono possibili. Di conseguenza, una chiamata al Convert.ToBoolean(DateTime) metodo, ad esempio, genera un NotSupportedException eccezione perché non esiste alcuna conversione possibili tra un DateTime e un Boolean valore

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

La chiamata al metodo non è assegnato lo stato dell'oggetto.

Si sta tentando di richiamare un membro la cui funzionalità è disponibile a causa dello stato dell'oggetto. È possibile eliminare l'eccezione in uno dei tre modi:

  • Si conosce in anticipo lo stato dell'oggetto, ma è stato richiamato un metodo non supportato o una proprietà. In questo caso, la chiamata al membro è un errore e viene eliminato.

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

    using System;
    using System.IO;
    using System.Text;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void 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) ); 
          t2.Wait();
          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()
    

    È possibile eliminare l'eccezione, garantendo che l'oggetto istanza supporta la funzionalità desiderata. Nell'esempio seguente risolve il problema di sola lettura FileStream oggetto fornendo gli argomenti appropriati per il FileStream.FileStream(String, FileMode, FileAccess) costruttore.

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

    L'esempio seguente definisce una DetectEncoding metodo che genera un NotSupportedException eccezione durante il tentativo 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 void Main()
       {
          String name = @".\TestFile.dat";
          var fs = new FileStream(name, 
                                  FileMode.Create,
                                  FileAccess.Write);
             Console.WriteLine("Filename: {0}, Encoding: {1}", 
                               name, FileUtilities.GetEncodingType(fs));
       }
    }
    
    public class FileUtilities
    {
       public enum EncodingType
       { None = 0, Unknown = -1, Utf8 = 1, Utf16 = 2, Utf32 = 3 }
    
       public static EncodingType GetEncodingType(FileStream fs)
       {
          Byte[] bytes = new Byte[4];
          var t = fs.ReadAsync(bytes, 0, 4);
          t.Wait();
          int bytesRead = t.Result;
          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.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 di FileStream.CanRead proprietà e metodo esistente se il flusso è di sola lettura.

       public static EncodingType GetEncodingType(FileStream fs)
       {
          if (!fs.CanRead) 
             return EncodingType.Unknown;
    
          Byte[] bytes = new Byte[4];
          var t = fs.ReadAsync(bytes, 0, 4);
          t.Wait();
          int bytesRead = t.Result;
          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
    

Il NotSupportedException eccezione è strettamente correlata ai due altri tipi di eccezione.

NotImplementedException.

Questa eccezione viene generata quando un metodo può essere implementato ma non lo è, in quanto 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 in scenari in cui è in genere a volte possibile per l'oggetto eseguire l'operazione richiesta e lo stato dell'oggetto determina se l'operazione può essere eseguita.

Quando si utilizza .NET Compact Framework e si applica P/Invoke a una funzione nativa, è possibile che venga generata questa eccezione se:

  • La dichiarazione nel codice gestito non è corretta.

  • L'operazione che si sta tentando di eseguire non è supportata in .NET Compact Framework.

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

Se un NotSupportedException viene generata l'eccezione, controllare:

  • Verificare eventuali violazioni delle limitazioni di P/Invoke in .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. Ciò può essere verificato con DumpBin.exe.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Portable Class Library
Supportato in: portable .NET platforms
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

Eventuali membri pubblici statici (Shared in Visual Basic) di questo tipo sono thread-safe. I membri di istanza non sono garantiti come thread-safe.

Torna all'inizio
Mostra: