Encoding.GetMaxByteCount-Methode
Berechnet beim Überschreiben in einer abgeleiteten Klasse die maximale Anzahl der Bytes, die beim Codieren der angegebenen Anzahl von Zeichen erzeugt wird.
Namespace: System.Text
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public MustOverride Function GetMaxByteCount ( _
charCount As Integer _
) As Integer
'Usage
Dim instance As Encoding
Dim charCount As Integer
Dim returnValue As Integer
returnValue = instance.GetMaxByteCount(charCount)
public abstract int GetMaxByteCount (
int charCount
)
public:
virtual int GetMaxByteCount (
int charCount
) abstract
public abstract int GetMaxByteCount (
int charCount
)
public abstract function GetMaxByteCount (
charCount : int
) : int
Parameter
- charCount
Die Anzahl der zu codierenden Zeichen.
Rückgabewert
Die maximale Anzahl an Bytes, die beim Codieren der angegebenen Anzahl von Zeichen erzeugt wird.
Ausnahmen
| Ausnahmetyp | Bedingung |
|---|---|
charCount ist kleiner als 0 (null). |
Hinweise
Der charCount-Parameter legt die Anzahl der Char-Objekte fest, die die zu codierenden Unicode-Zeichen darstellen. Dies erfolgt, da in .NET Framework UTF-16 zur Darstellung von Unicode-Zeichen verwendet wird. Aus diesem Grund können die meisten Unicode-Zeichen durch ein Char-Objekt dargestellt werden. Ein Unicode-Zeichen, das von einem Ersatzzeichenpaar dargestellt wird, benötigt jedoch z. B. zwei Char-Objekte.
Verwenden Sie die GetByteCount-Methode zum Berechnen der exakten Arraygröße, die von GetBytes zum Speichern der sich ergebenden Bytes benötigt wird. Verwenden Sie die GetMaxByteCount-Methode zum Berechnen der maximalen Arraygröße. Die GetByteCount-Methode ermöglicht Ihnen, weniger Speicher zuzuordnen, wohingegen die GetMaxByteCount-Methode in der Regel schneller ausgeführt wird.
Hinweise für Implementierer Bei sämtlichen Implementierungen von Encoding muss sichergestellt werden, dass keine Ausnahmen durch Pufferüberlauf ausgelöst werden, wenn die Puffergröße den Berechnungsergebnissen dieser Methode entspricht.
Beispiel
Im folgenden Codebeispiel wird die Anzahl der zum Codieren eines Zeichenarrays erforderlichen Bytes bestimmt; weiterhin werden die Zeichen codiert und die sich ergebenden Bytes angezeigt.
Imports System
Imports System.Text
Imports Microsoft.VisualBasic
Public Class SamplesEncoding
Public Shared Sub Main()
' The characters to encode:
' Latin Small Letter Z (U+007A)
' Latin Small Letter A (U+0061)
' Combining Breve (U+0306)
' Latin Small Letter AE With Acute (U+01FD)
' Greek Small Letter Beta (U+03B2)
' a high-surrogate value (U+D8FF)
' a low-surrogate value (U+DCFF)
Dim myChars() As Char = {"z"c, "a"c, ChrW(&H0306), ChrW(&H01FD), ChrW(&H03B2), ChrW(&HD8FF), ChrW(&HDCFF)}
' Get different encodings.
Dim u7 As Encoding = Encoding.UTF7
Dim u8 As Encoding = Encoding.UTF8
Dim u16LE As Encoding = Encoding.Unicode
Dim u16BE As Encoding = Encoding.BigEndianUnicode
Dim u32 As Encoding = Encoding.UTF32
' Encode the entire array, and print out the counts and the resulting bytes.
PrintCountsAndBytes(myChars, u7)
PrintCountsAndBytes(myChars, u8)
PrintCountsAndBytes(myChars, u16LE)
PrintCountsAndBytes(myChars, u16BE)
PrintCountsAndBytes(myChars, u32)
End Sub 'Main
Public Shared Sub PrintCountsAndBytes(chars() As Char, enc As Encoding)
' Display the name of the encoding used.
Console.Write("{0,-30} :", enc.ToString())
' Display the exact byte count.
Dim iBC As Integer = enc.GetByteCount(chars)
Console.Write(" {0,-3}", iBC)
' Display the maximum byte count.
Dim iMBC As Integer = enc.GetMaxByteCount(chars.Length)
Console.Write(" {0,-3} :", iMBC)
' Encode the array of chars.
Dim bytes As Byte() = enc.GetBytes(chars)
' Display all the encoded bytes.
PrintHexBytes(bytes)
End Sub 'PrintCountsAndBytes
Public Shared Sub PrintHexBytes(bytes() As Byte)
If bytes Is Nothing OrElse bytes.Length = 0 Then
Console.WriteLine("<none>")
Else
Dim i As Integer
For i = 0 To bytes.Length - 1
Console.Write("{0:X2} ", bytes(i))
Next i
Console.WriteLine()
End If
End Sub 'PrintHexBytes
End Class 'SamplesEncoding
'This code produces the following output.
'
'System.Text.UTF7Encoding : 18 23 :7A 61 2B 41 77 59 42 2F 51 4F 79 32 50 2F 63 2F 77 2D
'System.Text.UTF8Encoding : 12 24 :7A 61 CC 86 C7 BD CE B2 F1 8F B3 BF
'System.Text.UnicodeEncoding : 14 16 :7A 00 61 00 06 03 FD 01 B2 03 FF D8 FF DC
'System.Text.UnicodeEncoding : 14 16 :00 7A 00 61 03 06 01 FD 03 B2 D8 FF DC FF
'System.Text.UTF32Encoding : 24 32 :7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00 FF FC 04 00
using System;
using System.Text;
public class SamplesEncoding {
public static void Main() {
// The characters to encode:
// Latin Small Letter Z (U+007A)
// Latin Small Letter A (U+0061)
// Combining Breve (U+0306)
// Latin Small Letter AE With Acute (U+01FD)
// Greek Small Letter Beta (U+03B2)
// a high-surrogate value (U+D8FF)
// a low-surrogate value (U+DCFF)
char[] myChars = new char[] { 'z', 'a', '\u0306', '\u01FD', '\u03B2', '\uD8FF', '\uDCFF' };
// Get different encodings.
Encoding u7 = Encoding.UTF7;
Encoding u8 = Encoding.UTF8;
Encoding u16LE = Encoding.Unicode;
Encoding u16BE = Encoding.BigEndianUnicode;
Encoding u32 = Encoding.UTF32;
// Encode the entire array, and print out the counts and the resulting bytes.
PrintCountsAndBytes( myChars, u7 );
PrintCountsAndBytes( myChars, u8 );
PrintCountsAndBytes( myChars, u16LE );
PrintCountsAndBytes( myChars, u16BE );
PrintCountsAndBytes( myChars, u32 );
}
public static void PrintCountsAndBytes( char[] chars, Encoding enc ) {
// Display the name of the encoding used.
Console.Write( "{0,-30} :", enc.ToString() );
// Display the exact byte count.
int iBC = enc.GetByteCount( chars );
Console.Write( " {0,-3}", iBC );
// Display the maximum byte count.
int iMBC = enc.GetMaxByteCount( chars.Length );
Console.Write( " {0,-3} :", iMBC );
// Encode the array of chars.
byte[] bytes = enc.GetBytes( chars );
// Display all the encoded bytes.
PrintHexBytes( bytes );
}
public static void PrintHexBytes( byte[] bytes ) {
if (( bytes == null ) || ( bytes.Length == 0 ))
Console.WriteLine( "<none>" );
else {
for ( int i = 0; i < bytes.Length; i++ )
Console.Write( "{0:X2} ", bytes[i] );
Console.WriteLine();
}
}
}
/*
This code produces the following output.
System.Text.UTF7Encoding : 18 23 :7A 61 2B 41 77 59 42 2F 51 4F 79 32 50 2F 63 2F 77 2D
System.Text.UTF8Encoding : 12 24 :7A 61 CC 86 C7 BD CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding : 14 16 :7A 00 61 00 06 03 FD 01 B2 03 FF D8 FF DC
System.Text.UnicodeEncoding : 14 16 :00 7A 00 61 03 06 01 FD 03 B2 D8 FF DC FF
System.Text.UTF32Encoding : 24 32 :7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00 FF FC 04 00
*/
using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, Encoding^ enc );
void PrintHexBytes( array<Byte>^bytes );
int main()
{
// The characters to encode:
// Latin Small Letter Z (U+007A)
// Latin Small Letter A (U+0061)
// Combining Breve (U+0306)
// Latin Small Letter AE With Acute (U+01FD)
// Greek Small Letter Beta (U+03B2)
// a high-surrogate value (U+D8FF)
// a low-surrogate value (U+DCFF)
array<Char>^myChars = gcnew array<Char>{
L'z','a',L'\u0306',L'\u01FD',L'\u03B2',L'\xD8FF',L'\xDCFF'
};
// Get different encodings.
Encoding^ u7 = Encoding::UTF7;
Encoding^ u8 = Encoding::UTF8;
Encoding^ u16LE = Encoding::Unicode;
Encoding^ u16BE = Encoding::BigEndianUnicode;
Encoding^ u32 = Encoding::UTF32;
// Encode the entire array, and print out the counts and the resulting bytes.
PrintCountsAndBytes( myChars, u7 );
PrintCountsAndBytes( myChars, u8 );
PrintCountsAndBytes( myChars, u16LE );
PrintCountsAndBytes( myChars, u16BE );
PrintCountsAndBytes( myChars, u32 );
}
void PrintCountsAndBytes( array<Char>^chars, Encoding^ enc )
{
// Display the name of the encoding used.
Console::Write( "{0,-30} :", enc );
// Display the exact byte count.
int iBC = enc->GetByteCount( chars );
Console::Write( " {0,-3}", iBC );
// Display the maximum byte count.
int iMBC = enc->GetMaxByteCount( chars->Length );
Console::Write( " {0,-3} :", iMBC );
// Encode the array of chars.
array<Byte>^bytes = enc->GetBytes( chars );
// Display all the encoded bytes.
PrintHexBytes( bytes );
}
void PrintHexBytes( array<Byte>^bytes )
{
if ( (bytes == nullptr) || (bytes->Length == 0) )
Console::WriteLine( "<none>" );
else
{
for ( int i = 0; i < bytes->Length; i++ )
Console::Write( "{0:X2} ", bytes[ i ] );
Console::WriteLine();
}
}
/*
This code produces the following output.
System.Text.UTF7Encoding : 18 23 :7A 61 2B 41 77 59 42 2F 51 4F 79 32 50 2F 63 2F 77 2D
System.Text.UTF8Encoding : 12 24 :7A 61 CC 86 C7 BD CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding : 14 16 :7A 00 61 00 06 03 FD 01 B2 03 FF D8 FF DC
System.Text.UnicodeEncoding : 14 16 :00 7A 00 61 03 06 01 FD 03 B2 D8 FF DC FF
System.Text.UTF32Encoding : 24 32 :7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00 FF FC 04 00
*/
import System.*;
import System.Text.*;
import System.Byte;
public class SamplesEncoding
{
public static void main(String[] args)
{
// The characters to encode:
// Latin Small Letter Z (U+007A)
// Latin Small Letter A (U+0061)
// Combining Breve (U+0306)
// Latin Small Letter AE With Acute (U+01FD)
// Greek Small Letter Beta (U+03B2)
// a high-surrogate value (U+D8FF)
// a low-surrogate value (U+DCFF)
char myChars[] = new char[] {
'z', 'a', '\u0306', '\u01FD', '\u03B2', '\uD8FF', '\uDCFF'
};
// Get different encodings.
Encoding u7 = Encoding.get_UTF7();
Encoding u8 = Encoding.get_UTF8();
Encoding u16LE = Encoding.get_Unicode();
Encoding u16BE = Encoding.get_BigEndianUnicode();
Encoding u32 = Encoding.get_UTF32();
// Encode the entire array, and print out the counts
// and the resulting bytes.
PrintCountsAndBytes(myChars, u7);
PrintCountsAndBytes(myChars, u8);
PrintCountsAndBytes(myChars, u16LE);
PrintCountsAndBytes(myChars, u16BE);
PrintCountsAndBytes(myChars, u32);
} //main
public static void PrintCountsAndBytes(char chars[], Encoding enc)
{
// Display the name of the encoding used.
Console.Write("{0,-30} :", enc.toString());
// Display the exact byte count.
int iBC = enc.GetByteCount(chars);
Console.Write(" {0,-3}", String.valueOf(iBC));
// Display the maximum byte count.
int iMBC = enc.GetMaxByteCount(chars.length);
Console.Write(" {0,-3} :", String.valueOf(iMBC));
// Encode the array of chars.
ubyte bytes[] = enc.GetBytes(chars);
// Display all the encoded bytes.
PrintHexBytes(bytes);
} //PrintCountsAndBytes
public static void PrintHexBytes(ubyte bytes[])
{
if(bytes == null || bytes.length == 0) {
Console.WriteLine("<none>");
}
else {
for(int i = 0; i < bytes.length; i++) {
Console.Write("{0:X2} ",
((System.Byte)bytes[i]).ToString("X2"));
}
Console.WriteLine();
}
} //PrintHexBytes
} //SamplesEncoding
/*
This code produces the following output.
System.Text.UTF7Encoding : 18 23 :7A 61 2B 41 77 59 42 2F 51 4F 79 32 50
2F 63 2F 77 2D
System.Text.UTF8Encoding : 12 24 :7A 61 CC 86 C7 BD CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding : 14 16 :7A 00 61 00 06 03 FD 01 B2 03 FF D8 FF
DC
System.Text.UnicodeEncoding : 14 16 :00 7A 00 61 03 06 01 FD 03 B2 D8 FF DC
FF
System.Text.UTF32Encoding : 24 32 :7A 00 00 00 61 00 00 00 06 03 00 00 FD
01 00 00 B2 03 00 00 FF FC 04 00
*/
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
Encoding-Klasse
Encoding-Member
System.Text-Namespace
GetBytes
GetByteCount
GetEncoder