System.NotSupportedException sınıfı

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

NotSupportedException , çağrılan bir yöntem veya özellik için hiçbir uygulamanın mevcut olmadığını gösterir.

NotSupportedException , 0x80131515 değerine sahip HRESULT COR_E_NOTSUPPORTEDkullanır.

NotSupportedExceptionörneğinin ilk özellik değerlerinin listesi için bkz. NotSupportedException oluşturucuları.

NotSupportedException özel durumu fırlatma

Aşağıdaki durumlarda bir NotSupportedException özel durum oluşturmayı düşünebilirsiniz:

Genel amaçlı bir arabirim uyguluyorsunuz ve yöntem sayısının anlamlı bir uygulaması yok. Örneğin, arabirimi uygulayan IConvertible bir tarih ve saat türü oluşturuyorsanız, dönüştürmelerin çoğu için bir NotSupportedException özel durum oluşturursunuz.
Bir dizi yöntemi geçersiz kılmanızı gerektiren bir soyut sınıftan devralınmışsınız. Ancak, bunların yalnızca bir alt kümesi için bir uygulama sağlamaya hazırsınız. Uygulamamaya karar verdiğiniz yöntemler için bir NotSupportedException oluşturmayı seçebilirsiniz.
İşlemleri koşullu olarak etkinleştiren bir duruma sahip genel amaçlı bir tür tanımlaıyorsunuz. Örneğin, türünüz salt okunur veya okuma-yazma olabilir. Bu durumda:
- Nesne salt okunursa, bir örneğin özelliklerine değer atamaya çalışmak veya örnek durumunu değiştiren yöntemleri çağırmak bir NotSupportedException özel durumu atmalıdır.
- Belirli işlevlerin kullanılabilir olup olmadığını gösteren bir değer döndüren bir Boolean özellik uygulamanız gerekir. Örneğin, salt okunur veya okuma-yazma olabilen bir tür için, okuma-yazma yöntemleri kümesinin kullanılabilir veya kullanılamadığını belirten bir IsReadOnly özellik uygulayabilirsiniz.

NotSupportedException özel durumunu işleme

İstisna NotSupportedException göstergesi, bir yöntemin uygulaması olmadığını ve onu çağırmamanız gerektiğini belirtir. Özel durumu ele almamalısınız. Bunun yerine, yapmanız gereken, özel durumun nedenine bağlıdır: bir uygulamanın tamamen eksik olup olmadığı veya üye çağrısının nesnenin amacıyla (salt okunur FileStream.Write nesnedeki FileStream yöntemine yapılan çağrı gibi) tutarsız olup olmamasıdır.

İşlem anlamlı bir şekilde gerçekleştirilemediğinden bir uygulama sağlanmadı. Bu, soyut bir temel sınıfın yöntemleri için uygulamalar sağlayan veya genel amaçlı bir arabirim uygulayan ve yöntemin anlamlı bir uygulaması olmayan bir nesnede yöntemleri çağırdığınızda yaygın bir özel durumdur.

Örneğin, Convert sınıfı arabirimini IConvertible uygular, yani her temel türü diğer ilkel türlere dönüştürmek için bir yöntem içermesi gerekir. Ancak bu dönüştürmelerin çoğu mümkün değildir. Sonuç olarak, örneğin Convert.ToBoolean(DateTime) yöntemine yapılan bir çağrı, NotSupportedException ve DateTime arasında olası bir dönüşüm olmadığından bir Boolean istisna fırlatır.

Özel durumu ortadan kaldırmak için yöntem çağrısını ortadan kaldırmanız gerekir.

Nesnenin durumu göz önünde bulundurulduğunda yöntem çağrısı desteklenmez. Nesnenin durumu nedeniyle işlevselliği kullanılamayan bir üyeyi çağırmaya çalışıyorsunuz. Özel durumu üç yoldan biriyle ortadan kaldırabilirsiniz:

Nesnenin durumunu önceden biliyorsunuz, ancak desteklenmeyen bir yöntemi veya özelliği çağırmışsınız. Bu durumda, üye çağırma bir hatadır ve bunu ortadan kaldırabilirsiniz.

Nesnenin durumunu önceden biliyorsunuz (genellikle kodunuz örneği oluşturduğundan), ancak nesne yanlış yapılandırılmış. Aşağıdaki örnekte bu sorun gösterilmektedir. Salt okunur bir FileStream nesne oluşturur ve ardından ona yazmayı dener.

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, örneklenen nesnenin amaçladığınız işlevselliği desteklediğinden emin olarak özel durumu ortadan kaldırır. Aşağıdaki örnek, FileStream salt okunur nesne sorununu, FileStream.FileStream(String, FileMode, FileAccess) oluşturucuya doğru bağımsız değişkenleri sağlayarak ele alır.

Nesnenin durumunu önceden bilmiyorsunuz ve nesne belirli bir işlemi desteklemiyor. Çoğu durumda, nesnenin belirli bir işlem kümesini destekleyip desteklemediğini gösteren bir özellik veya yöntem içermesi gerekir. Nesnenin değerini denetleyerek ve üyeyi yalnızca uygunsa çağırarak özel durumu ortadan kaldırabilirsiniz.

Aşağıdaki örnek, okuma erişimini desteklemeyen bir akışın başından itibaren okumaya çalıştığında bir DetectEncoding istisnası fırlatan bir NotSupportedException yöntemi tanımlar.

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

Özel durumu ortadan kaldırmak için, FileStream.CanRead özelliğinin değerini inceleyerek ve akış salt okunursa yöntemden çıkmak için işleyişi durdurabilirsiniz.

    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

Özel NotSupportedException durum diğer iki özel durum türüyle yakından ilgilidir;

NotImplementedException

Bu özel durum, bir yöntemin uygulanabilmesine rağmen uygulanamadığı durumlarda oluşur. Bunun nedeni, üyenin daha sonraki bir sürümde uygulanması, üyenin belirli bir platformda mevcut olmaması veya üyenin soyut bir sınıfa ait olması ve türetilmiş bir sınıfın bir uygulama sağlaması gerekir.
InvalidOperationException

Bu özel durum, nesnenin istenen işlemi gerçekleştirmesinin genellikle mümkün olduğu senaryolarda oluşturulur ve nesne durumu işlemin gerçekleştirilip gerçekleştirilemeyeceğini belirler.

.NET Compact Framework notları

.NET Compact Framework ile çalışırken ve yerel bir işlevde P/Invoke kullanırken, aşağıdaki durumlarda bu özel durum oluşabilir:

Yönetilen koddaki bildirim yanlış.
.NET Compact Framework, yapmaya çalıştığınız şeyi desteklemiyor.
DLL adları dışa aktarılırken bozulur.

Özel durum NotSupportedException oluşursa şunları denetleyin:

.NET Compact Framework P/Invoke kısıtlamalarının ihlalleri için.
Önceden tahsis edilmiş bellek gerektiren parametreler için. Eğer bunlar varsa, mevcut bir değişkene referans geçirmelisiniz.
Dışarı aktarılan işlevlerin adlarının doğru olduğunu. Bu ,DumpBin.exeile doğrulanabilir.
Çok fazla bağımsız değişken geçirmeye çalışmadığınızdan emin olun.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-06-17

Aracılığıyla paylaş

System.NotSupportedException sınıfı

NotSupportedException özel durumu fırlatma

NotSupportedException özel durumunu işleme

İlgili özel durum türleri

.NET Compact Framework notları

Geri Bildirim

Ek kaynaklar