System.NotSupportedException-Klasse

Artikel
01/11/2024

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

NotSupportedException gibt an, dass für eine aufgerufene Methode oder Eigenschaft keine Implementierung vorhanden ist.

NotSupportedException verwendet den HRESULT-Datentyp COR_E_NOTSUPPORTED mit dem Wert 0x80131515.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von NotSupportedException, finden Sie unter den NotSupportedException Konstruktoren.

Auslösen einer NotSupportedException-Ausnahme

In den folgenden Fällen könnten Sie erwägen, eine NotSupportedException-Ausnahme auszulösen:

Sie implementieren eine allgemeine Schnittstelle, und einige Methoden sind nicht sinnvoll implementiert. Wenn Sie beispielsweise einen Datums- und Uhrzeittyp erstellen, der die IConvertible-Schnittstelle implementiert, würden Sie für die meisten Konvertierungen eine NotSupportedException-Ausnahme auslösen.
Sie haben von einer abstrakten Klasse geerbt, die das Überschreiben einer Reihe von Methoden erfordert. Allerdings möchten Sie lediglich für eine Teilmenge dieser Klassen eine Implementierung bereitstellen. Für die Methoden, die Sie nicht implementieren möchten, können Sie eine NotSupportedException-Ausnahme auslösen.
Sie definieren einen allgemeinen Typ mit einem Status, der Vorgänge bedingt ermöglicht. Ihr Typ kann beispielsweise schreibgeschützt oder les- und schreibbar sein. Dabei trifft Folgendes zu:
- Eine NotSupportedException-Ausnahme sollte für schreibgeschützte Objekte beim Versuch ausgelöst werden, den Eigenschaften einer Instanz oder Methoden, die den Status der Instanz ändern, Werte zuzuweisen.
- Sie sollten eine Eigenschaft implementieren, die einen Boolean-Wert zurückgibt, der angibt, ob bestimmte Funktionen verfügbar sind. Beispielsweise könnten Sie für einen Typ, der schreibgeschützt oder les- und schreibbar sein kann, eine IsReadOnly-Eigenschaft implementieren, die angibt, ob die Lese-/Schreibmethoden verfügbar sind.

Behandeln einer NotSupportedException-Ausnahme

Die NotSupportedException-Ausnahme gibt an, dass eine Methode über keine Implementierung verfügt und nicht aufgerufen werden sollten. Sie sollten die Ausnahme nicht behandeln. Ihre weitere Vorgehensweise hängt davon ab, ob die Ursache der Ausnahme in einer nicht vorhandenen Implementierung oder in einem inkonsistenten Memberaufruf mit dem Zweck eines Objekts wie dem Aufruf der FileStream.Write-Methode für ein schreibgeschütztes FileStream-Objekt liegt.

Eine Implementierung wurde nicht bereitgestellt, da der Vorgang nicht sinnvoll ausgeführt werden kann. Diese Ausnahme wird häufig beim Aufrufen von Methoden für ein Objekt ausgelöst, das Implementierungen für die Methoden einer abstrakten Stammklasse bereitstellt oder eine allgemeine Schnittstelle implementiert. Sie wird ebenfalls ausgelöst, wenn die Methode über keine sinnvolle Implementierung verfügt.

Beispielsweise implementiert die Convert-Klasse die IConvertible-Schnittstelle. Das bedeutet, dass sie eine Methode enthalten muss, mit der jeder primitive Typ in jeden anderen primitiven Typ konvertiert werden kann. Viele dieser Konvertierungen sind jedoch nicht möglich. Daher löst ein Aufruf der Convert.ToBoolean(DateTime)-Methode beispielsweise eine NotSupportedException-Ausnahme aus, weil zwischen den Werten DateTime und Boolean keine Konvertierung möglich ist.

Um die Ausnahme zu beseitigen, sollten Sie den Methodenaufruf beseitigen.

Der Methodenaufruf wird aufgrund des Objektstatus nicht unterstützt. Sie versuchen, ein Element aufzurufen, dessen Funktionalität aufgrund des Objektstatus nicht verfügbar ist. Sie können die Ausnahme auf eine von drei Arten beseitigen:

Sie kennen den Objektstatus im Voraus, haben jedoch eine nicht unterstützte Methode oder Eigenschaft aufgerufen. In diesem Fall ist der Aufruf des Members ein Fehler, den Sie beseitigen könnten.

Sie kennen den Objektstatus im Voraus, was in der Regel daran liegt, dass das Objekt durch Ihren Code instanziieren wurde. Das Objekt ist jedoch falsch konfiguriert. Dieses Problem wird im folgenden Beispiel veranschaulicht. Ein schreibgeschütztes FileStream-Objekt wird erstellt, woraufhin versucht wird, in das Objekt zu schreiben.

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

Ycan beseitigt die Ausnahme, indem sichergestellt wird, dass das instanziierte Objekt die gewünschte Funktionalität unterstützt. Im folgenden Beispiel wird das Problem des schreibgeschützten FileStream-Objekts behoben, indem dem FileStream.FileStream(String, FileMode, FileAccess)-Konstruktor die richtigen Argumente bereitgestellt werden.

Sie kennen den Objektstatus nicht im Voraus, und das Objekt unterstützt einen bestimmten Vorgang nicht. In den meisten Fällen sollte das Objekt eine Eigenschaft oder Methode enthalten, die angibt, ob es eine bestimmte Gruppe von Vorgängen unterstützt. Sie können die Ausnahme beseitigen, indem Sie den Wert des Objekts überprüfen und das Element lediglich bei Bedarf aufrufen.

Im folgenden Beispiel wird eine DetectEncoding-Methode definiert, die eine NotSupportedException-Ausnahme beim Versuch auslöst, aus dem Anfang eines Datenstroms zu lesen, der keinen Lesezugriff unterstützt.

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

Sie können die Ausnahme beseitigen, indem Sie den Wert der FileStream.CanRead-Eigenschaft untersuchen und die Methode beenden, wenn der Datenstrom schreibgeschützt ist.

    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

Die NotSupportedException-Ausnahme hängt eng mit zwei anderen Ausnahmetypen zusammen:

NotImplementedException

Diese Ausnahme wird ausgelöst, wenn eine Methode implementiert werden kann, jedoch nicht implementiert wird. Das könnte daran liegen, dass das Element in einer späteren Version implementiert wird, der Member nicht auf einer bestimmten Plattform verfügbar ist oder der Member zu einer abstrakten Klasse gehört und eine abgeleitete Klasse eine Implementierung bereitstellen muss.
InvalidOperationException

Diese Ausnahme wird in Szenarios ausgelöst, in denen das Objekt in der Regel den angeforderten Vorgang ausführen kann und der Objektstatus bestimmt, ob der Vorgang ausgeführt werden kann.

Hinweise zu .NET Compact Framework

Wenn Sie mit .NET Compact Framework arbeiten und P/Invoke für eine native Funktion verwenden, kann diese Ausnahme in den folgenden Szenarios ausgelöst werden:

Die Deklaration im verwalteten Code ist nicht korrekt.
.NET Compact Framework unterstützt den gewünschten Vorgang nicht.
Die DLL-Namen werden beim Export geändert.

Wenn eine NotSupportedException-Ausnahme ausgelöst wird, überprüfen Sie Folgendes:

Verstößen gegen P/Invoke-Einschränkungen von .NET Compact Framework
Ob Argumente vorhanden sind, die im Voraus belegten Arbeitsspeicher erfordern. Falls sie vorhanden sind, sollten Sie einen Verweis auf eine vorhandene Variable übergeben.
Ob die Namen der exportierten Funktionen korrekt sind. Das kann mit DumpBin.exe überprüft werden.
Ob Sie zu viele Argumente zu übergeben versuchen.

Freigeben über

System.NotSupportedException-Klasse

Auslösen einer NotSupportedException-Ausnahme

Behandeln einer NotSupportedException-Ausnahme

Hinweise zu .NET Compact Framework

Zusätzliche Ressourcen

Freigeben über

System.NotSupportedException-Klasse

Auslösen einer NotSupportedException-Ausnahme

Behandeln einer NotSupportedException-Ausnahme

Verwandte Ausnahmetypen

Hinweise zu .NET Compact Framework

Zusätzliche Ressourcen