Encoder Sınıf

Tanım

Ad Alanı:

System.Text

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

Encoder.cs

Bir karakter kümesini bayt dizisine dönüştürür.

public ref class Encoder abstract

public abstract class Encoder

type Encoder = class

Public MustInherit Class Encoder

Devralma

Object

Encoder

Örnekler

Aşağıdaki örnekte, belirtilen kodlama kullanılarak unicode karakter dizisinin bayt bloklarına nasıl dönüştürüldüğü gösterilmektedir. Karşılaştırma için, karakter dizisi ilk olarak kullanılarak UTF7Encodingkodlanır. Ardından, karakter dizisi kullanılarak Encoderkodlanır.

using namespace System;
using namespace System::Text;
using namespace System::Collections;
void ShowArray( Array^ theArray )
{
   IEnumerator^ myEnum = theArray->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ o = safe_cast<Object^>(myEnum->Current);
      Console::Write( "[{0}]", o );
   }

   Console::WriteLine( "\n" );
}

int main()
{
   
   // The characters to encode.
   
   // Pi
   // Sigma
   array<Char>^chars = {L'\u03a0',L'\u03a3',L'\u03a6',L'\u03a9'};
   
   // Encode characters using an Encoding Object*.
   Encoding^ encoding = Encoding::UTF7;
   Console::WriteLine( "Using Encoding\n--------------" );
   
   // Encode complete array for comparison.
   array<Byte>^allCharactersFromEncoding = encoding->GetBytes( chars );
   Console::WriteLine( "All characters encoded:" );
   ShowArray( allCharactersFromEncoding );
   
   // Encode characters, one-by-one.
   // The Encoding Object* will NOT maintain state between calls.
   array<Byte>^firstchar = encoding->GetBytes( chars, 0, 1 );
   Console::WriteLine( "First character:" );
   ShowArray( firstchar );
   array<Byte>^secondchar = encoding->GetBytes( chars, 1, 1 );
   Console::WriteLine( "Second character:" );
   ShowArray( secondchar );
   array<Byte>^thirdchar = encoding->GetBytes( chars, 2, 1 );
   Console::WriteLine( "Third character:" );
   ShowArray( thirdchar );
   array<Byte>^fourthchar = encoding->GetBytes( chars, 3, 1 );
   Console::WriteLine( "Fourth character:" );
   ShowArray( fourthchar );
   
   // Now, encode characters using an Encoder Object*.
   Encoder^ encoder = encoding->GetEncoder();
   Console::WriteLine( "Using Encoder\n-------------" );
   
   // Encode complete array for comparison.
   array<Byte>^allCharactersFromEncoder = gcnew array<Byte>(encoder->GetByteCount( chars, 0, chars->Length, true ));
   encoder->GetBytes( chars, 0, chars->Length, allCharactersFromEncoder, 0, true );
   Console::WriteLine( "All characters encoded:" );
   ShowArray( allCharactersFromEncoder );
   
   // Do not flush state; i.e. maintain state between calls.
   bool bFlushState = false;
   
   // Encode characters one-by-one.
   // By maintaining state, the Encoder will not store extra bytes in the output.
   array<Byte>^firstcharNoFlush = gcnew array<Byte>(encoder->GetByteCount( chars, 0, 1, bFlushState ));
   encoder->GetBytes( chars, 0, 1, firstcharNoFlush, 0, bFlushState );
   Console::WriteLine( "First character:" );
   ShowArray( firstcharNoFlush );
   array<Byte>^secondcharNoFlush = gcnew array<Byte>(encoder->GetByteCount( chars, 1, 1, bFlushState ));
   encoder->GetBytes( chars, 1, 1, secondcharNoFlush, 0, bFlushState );
   Console::WriteLine( "Second character:" );
   ShowArray( secondcharNoFlush );
   array<Byte>^thirdcharNoFlush = gcnew array<Byte>(encoder->GetByteCount( chars, 2, 1, bFlushState ));
   encoder->GetBytes( chars, 2, 1, thirdcharNoFlush, 0, bFlushState );
   Console::WriteLine( "Third character:" );
   ShowArray( thirdcharNoFlush );
   
   // Must flush state on last call to GetBytes().
   bFlushState = true;
   array<Byte>^fourthcharNoFlush = gcnew array<Byte>(encoder->GetByteCount( chars, 3, 1, bFlushState ));
   encoder->GetBytes( chars, 3, 1, fourthcharNoFlush, 0, bFlushState );
   Console::WriteLine( "Fourth character:" );
   ShowArray( fourthcharNoFlush );
}

/* This code example produces the following output.

Using Encoding
--------------
All characters encoded:
[43][65][54][65][68][111][119][79][109][65][54][107][45]

First character:
[43][65][54][65][45]

Second character:
[43][65][54][77][45]

Third character:
[43][65][54][89][45]

Fourth character:
[43][65][54][107][45]

Using Encoder
-------------
All characters encoded:
[43][65][54][65][68][111][119][79][109][65][54][107][45]

First character:
[43][65][54]

Second character:
[65][68][111]

Third character:
[119][79][109]

Fourth character:
[65][54][107][45]


*/

using System;
using System.Text;

class EncoderTest {
    public static void Main() {
        // The characters to encode.
        Char[] chars = new Char[] {
            '\u0023', // #
            '\u0025', // %
            '\u03a0', // Pi
            '\u03a3'  // Sigma
        };

        // Encode characters using an Encoding object.
        Encoding encoding = Encoding.UTF7;
        Console.WriteLine("Using Encoding\n--------------");

        // Encode complete array for comparison.
        Byte[] allCharactersFromEncoding = encoding.GetBytes(chars);
        Console.WriteLine("All characters encoded:");
        ShowArray(allCharactersFromEncoding);

        // Encode characters, one-by-one.
        // The Encoding object will NOT maintain state between calls.
        Byte[] firstchar = encoding.GetBytes(chars, 0, 1);
        Console.WriteLine("First character:");
        ShowArray(firstchar);

        Byte[] secondchar = encoding.GetBytes(chars, 1, 1);
        Console.WriteLine("Second character:");
        ShowArray(secondchar);

        Byte[] thirdchar = encoding.GetBytes(chars, 2, 1);
        Console.WriteLine("Third character:");
        ShowArray(thirdchar);

        Byte[] fourthchar = encoding.GetBytes(chars, 3, 1);
        Console.WriteLine("Fourth character:");
        ShowArray(fourthchar);

        // Now, encode characters using an Encoder object.
        Encoder encoder = encoding.GetEncoder();
        Console.WriteLine("Using Encoder\n-------------");

        // Encode complete array for comparison.
        Byte[] allCharactersFromEncoder = new Byte[encoder.GetByteCount(chars, 0, chars.Length, true)];
        encoder.GetBytes(chars, 0, chars.Length, allCharactersFromEncoder, 0, true);
        Console.WriteLine("All characters encoded:");
        ShowArray(allCharactersFromEncoder);

        // Do not flush state; i.e. maintain state between calls.
        bool bFlushState = false;

        // Encode characters one-by-one.
        // By maintaining state, the Encoder will not store extra bytes in the output.
        Byte[] firstcharNoFlush = new Byte[encoder.GetByteCount(chars, 0, 1, bFlushState)];
        encoder.GetBytes(chars, 0, 1, firstcharNoFlush, 0, bFlushState);
        Console.WriteLine("First character:");
        ShowArray(firstcharNoFlush);

        Byte[] secondcharNoFlush = new Byte[encoder.GetByteCount(chars, 1, 1, bFlushState)];
        encoder.GetBytes(chars, 1, 1, secondcharNoFlush, 0, bFlushState);
        Console.WriteLine("Second character:");
        ShowArray(secondcharNoFlush);

        Byte[] thirdcharNoFlush = new Byte[encoder.GetByteCount(chars, 2, 1, bFlushState)];
        encoder.GetBytes(chars, 2, 1, thirdcharNoFlush, 0, bFlushState);
        Console.WriteLine("Third character:");
        ShowArray(thirdcharNoFlush);

        // Must flush state on last call to GetBytes().
        bFlushState = true;
        
        Byte[] fourthcharNoFlush = new Byte[encoder.GetByteCount(chars, 3, 1, bFlushState)];
        encoder.GetBytes(chars, 3, 1, fourthcharNoFlush, 0, bFlushState);
        Console.WriteLine("Fourth character:");
        ShowArray(fourthcharNoFlush);
    }

    public static void ShowArray(Array theArray) {
        foreach (Object o in theArray) {
            Console.Write("[{0}]", o);
        }
        Console.WriteLine("\n");
    }
}

/* This code example produces the following output.

Using Encoding
--------------
All characters encoded:
[43][65][67][77][65][74][81][79][103][65][54][77][45]

First character:
[43][65][67][77][45]

Second character:
[43][65][67][85][45]

Third character:
[43][65][54][65][45]

Fourth character:
[43][65][54][77][45]

Using Encoder
-------------
All characters encoded:
[43][65][67][77][65][74][81][79][103][65][54][77][45]

First character:
[43][65][67]

Second character:
[77][65][74]

Third character:
[81][79][103]

Fourth character:
[65][54][77][45]


*/

Imports System.Text
Imports Microsoft.VisualBasic.Strings

Class EncoderTest
    
    Public Shared Sub Main()
        ' Unicode characters.
        ' ChrW(35)  = #
        ' ChrW(37)  = %
        ' ChrW(928) = Pi
        ' ChrW(931) = Sigma
        Dim chars() As Char = {ChrW(35), ChrW(37), ChrW(928), ChrW(931)}
        
        ' Encode characters using an Encoding object.
        Dim encoding As Encoding = Encoding.UTF7
        Console.WriteLine( _
            "Using Encoding" & _
            ControlChars.NewLine & _
            "--------------" _
        )
        
        ' Encode complete array for comparison.
        Dim allCharactersFromEncoding As Byte() = encoding.GetBytes(chars)
        Console.WriteLine("All characters encoded:")
        ShowArray(allCharactersFromEncoding)
        
        ' Encode characters, one-by-one.
        ' The Encoding object will NOT maintain state between calls.
        Dim firstchar As Byte() = encoding.GetBytes(chars, 0, 1)
        Console.WriteLine("First character:")
        ShowArray(firstchar)
        
        Dim secondchar As Byte() = encoding.GetBytes(chars, 1, 1)
        Console.WriteLine("Second character:")
        ShowArray(secondchar)
        
        Dim thirdchar As Byte() = encoding.GetBytes(chars, 2, 1)
        Console.WriteLine("Third character:")
        ShowArray(thirdchar)
        
        Dim fourthchar As Byte() = encoding.GetBytes(chars, 3, 1)
        Console.WriteLine("Fourth character:")
        ShowArray(fourthchar)
        
        
        ' Now, encode characters using an Encoder object.
        Dim encoder As Encoder = encoding.GetEncoder()
        Console.WriteLine( _
            "Using Encoder" & _
            ControlChars.NewLine & _
            "-------------" _
        )
        
        ' Encode complete array for comparison.
        Dim allCharactersFromEncoder( _
            encoder.GetByteCount(chars, 0, chars.Length, True) _
        ) As Byte
        encoder.GetBytes(chars, 0, chars.Length, allCharactersFromEncoder, 0, True)
        Console.WriteLine("All characters encoded:")
        ShowArray(allCharactersFromEncoder)
        
        ' Do not flush state; i.e. maintain state between calls.
        Dim bFlushState As Boolean = False
        
        ' Encode characters one-by-one.
        ' By maintaining state, the Encoder will not store extra bytes in the output.
        Dim firstcharNoFlush( _
            encoder.GetByteCount(chars, 0, 1, bFlushState) _
        ) As Byte
        encoder.GetBytes(chars, 0, 1, firstcharNoFlush, 0, bFlushState)
        Console.WriteLine("First character:")
        ShowArray(firstcharNoFlush)
        
        Dim secondcharNoFlush( _
            encoder.GetByteCount(chars, 1, 1, bFlushState) _
        ) As Byte
        encoder.GetBytes(chars, 1, 1, secondcharNoFlush, 0, bFlushState)
        Console.WriteLine("Second character:")
        ShowArray(secondcharNoFlush)
        
        Dim thirdcharNoFlush( _
            encoder.GetByteCount(chars, 2, 1, bFlushState) _
        ) As Byte
        encoder.GetBytes(chars, 2, 1, thirdcharNoFlush, 0, bFlushState)
        Console.WriteLine("Third character:")
        ShowArray(thirdcharNoFlush)
        
        ' Must flush state on last call to GetBytes().
        bFlushState = True
        
        Dim fourthcharNoFlush( _
            encoder.GetByteCount(chars, 3, 1, bFlushState) _
        ) As Byte
        encoder.GetBytes(chars, 3, 1, fourthcharNoFlush, 0, bFlushState)
        Console.WriteLine("Fourth character:")
        ShowArray(fourthcharNoFlush)
    End Sub
    
    
    Public Shared Sub ShowArray(theArray As Array)
        Dim o As Object
        For Each o In  theArray
            Console.Write("[{0}]", o)
        Next o
        Console.WriteLine(ControlChars.NewLine)
    End Sub
End Class

'This code example produces the following output.
'
'Using Encoding
'--------------
'All characters encoded:
'[43][65][67][77][65][74][81][79][103][65][54][77][45]
'
'First character:
'[43][65][67][77][45]
'
'Second character:
'[43][65][67][85][45]
'
'Third character:
'[43][65][54][65][45]
'
'Fourth character:
'[43][65][54][77][45]
'
'Using Encoder
'-------------
'All characters encoded:
'[43][65][67][77][65][74][81][79][103][65][54][77][45][0]
'
'First character:
'[43][65][67][0]
'
'Second character:
'[77][65][74][0]
'
'Third character:
'[81][79][103][0]
'
'Fourth character:
'[65][54][77][45][0]
'

Açıklamalar

Sınıfının bir uygulamasının Encoder örneğini almak için uygulamanın bir Encoding uygulama yöntemini kullanması GetEncoder gerekir.

GetByteCount yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes belirler ve yöntem gerçek kodlamayı gerçekleştirir. Sınıfında bu yöntemlerin birkaç sürümü vardır Encoder . Daha fazla bilgi için bkz. Encoding.GetBytes.

Bir Encoder nesne, blokları kapsayan karakter dizilerini doğru bir şekilde kodlamak için ardışık GetBytes çağrılar veya Convert yöntemleri arasında durum bilgilerini korur. ayrıca Encoder veri bloklarının sonundaki karakterleri korur ve sonraki kodlama işleminde sondaki karakterleri kullanır. Örneğin, bir veri bloğu eşleşmeyen bir yüksek vekille sona erebilir ve eşleşen düşük vekil sonraki veri bloğunda olabilir. Bu nedenle, GetDecoder ve GetEncoder ağ iletimi ve dosya işlemleri için yararlıdır, çünkü bu işlemler genellikle tam bir veri akışı yerine veri bloklarıyla ilgilenir.

Not

Uygulama bir veri akışıyla tamamlandığında, uygun yöntem çağrısında parametresi true ayarlanarak flush durum bilgilerinin temizlendiğinden emin olmalıdır. Bir özel durum oluşursa veya uygulama akışları değiştirirse, nesnenin iç durumunu Encoder temizlemek için çağrısı Reset yapmalıdır.

Uygulayanlara Notlar

Uygulamanız bu sınıftan devraldığında tüm üyeleri geçersiz kılmalıdır.

Oluşturucular

Encoder()

Encoder sınıfının yeni bir örneğini başlatır.

Özellikler

Fallback	Geçerli Encoder nesne için bir EncoderFallback nesne alır veya ayarlar.
FallbackBuffer	EncoderFallbackBuffer Geçerli Encoder nesneyle ilişkili nesneyi alır.

Yöntemler

Convert(Char*, Int32, Byte*, Int32, Boolean, Int32, Int32, Boolean)	Unicode karakterlerin arabelleği kodlanmış bayt dizisine dönüştürür ve sonucu başka bir arabellekte depolar.
Convert(Char[], Int32, Int32, Byte[], Int32, Int32, Boolean, Int32, Int32, Boolean)	Unicode karakter dizisini kodlanmış bir bayt dizisine dönüştürür ve sonucu bir bayt dizisi olarak depolar.
Convert(ReadOnlySpan<Char>, Span<Byte>, Boolean, Int32, Int32, Boolean)	Unicode karakterlerin bir aralığını kodlanmış bayt dizisine dönüştürür ve sonucu başka bir arabellekte depolar.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetByteCount(Char*, Int32, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter işaretçisinde başlayan bir karakter kümesini kodlayarak üretilen bayt sayısını hesaplar. Parametre, hesaplamadan sonra kodlayıcının iç durumunun temizlenip temizlenmeyeceğini gösterir.
GetByteCount(Char[], Int32, Int32, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter dizisinden bir karakter kümesi kodlayarak üretilen bayt sayısını hesaplar. Parametre, hesaplamadan sonra kodlayıcının iç durumunun temizlenip temizlenmeyeceğini gösterir.
GetByteCount(ReadOnlySpan<Char>, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, 'chars' yayılma alanında bir karakter kümesi kodlayarak üretilen bayt sayısını hesaplar. Parametre, hesaplamadan sonra kodlayıcının iç durumunun temizlenip temizlenmeyeceğini gösterir.
GetBytes(Char*, Int32, Byte*, Int32, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter işaretçisinde başlayan bir karakter kümesini ve iç arabellekteki karakterleri belirtilen bayt işaretçisinde başlayan bir bayt dizisine kodlar. Parametre, dönüştürmeden sonra kodlayıcının iç durumunun temizlenip temizlenmeyeceğini gösterir.
GetBytes(Char[], Int32, Int32, Byte[], Int32, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter dizisindeki bir karakter kümesini ve iç arabellekteki karakterleri belirtilen bayt dizisine kodlar. Parametre, dönüştürmeden sonra kodlayıcının iç durumunun temizlenip temizlenmeyeceğini gösterir.
GetBytes(ReadOnlySpan<Char>, Span<Byte>, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, giriş karakterleri aralığındaki bir karakter kümesini ve iç arabellekteki karakterleri giriş bayt aralığında depolanan bir bayt dizisine kodlar. Parametre, dönüştürmeden sonra kodlayıcının iç durumunun temizlenip temizlenmeyeceğini gösterir.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
Reset()	Türetilmiş bir sınıfta geçersiz kılındığında kodlayıcıyı ilk durumuna geri ayarlar.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)

Uzantı Metotları

Convert(Encoder, ReadOnlySequence<Char>, IBufferWriter<Byte>, Boolean, Int64, Boolean)	Bir ReadOnlySequence<T> öğesini kodlanmış baytlara dönüştürür ve sonucu öğesine writeryazar.
Convert(Encoder, ReadOnlySpan<Char>, IBufferWriter<Byte>, Boolean, Int64, Boolean)	kullanarak encoder bir ReadOnlySpan<T> bayt değerini bayt değerine dönüştürür ve sonucu öğesine writeryazar.

Ayrıca bkz.

• Decoder
• Encoding
• Kodlamaları Anlama