Export (0) Print
Expand All

Encoding.GetString Method (Byte[])

When overridden in a derived class, decodes all the bytes in the specified byte array into a string.

Namespace:  System.Text
Assemblies:   System.Text.Encoding (in System.Text.Encoding.dll)
  mscorlib (in mscorlib.dll)

public virtual string GetString(
	byte[] bytes
)

Parameters

bytes
Type: System.Byte[]

The byte array containing the sequence of bytes to decode.

Return Value

Type: System.String
A string that contains the results of decoding the specified sequence of bytes.

ExceptionCondition
ArgumentException

The byte array contains invalid Unicode code points.

ArgumentNullException

bytes is null.

DecoderFallbackException

A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)

-and-

DecoderFallback is set to DecoderExceptionFallback.

If the data to be converted is available only in sequential blocks (such as data read from a stream) or if the amount of data is so large that it needs to be divided into smaller blocks, you should use the Decoder object returned by the GetDecoder method of a derived class.

See the Remarks section of the Encoding.GetChars reference topic for a discussion of decoding techniques and considerations.

Note that the precise behavior of the GetString method for a particular Encoding implementation depends on the fallback strategy defined for that Encoding object. For more information, see the "Choosing a Fallback Strategy" section of the Character Encoding in the .NET Framework topic.

The following example reads a UTF-8 encoded string from a binary file represented by a FileStream object. For files that are smaller than 2,048 bytes, it reads the contents of the entire file into a byte array and calls the GetString(Byte[]) method to perform the decoding. For larger files, it reads 2,048 bytes at a time into a byte array, calls the Decoder.GetCharCount(Byte[], Int32, Int32) method to determine how many characters are contained in the array, and then calls the Decoder.GetChars(Byte[], Int32, Int32, Char[], Int32) method to perform the decoding.

using System;
using System.IO;
using System.Text;

public class Example
{
   const int MAX_BUFFER_SIZE = 2048;
   static Encoding enc8 = Encoding.UTF8;

   public static void Main()
   {
      FileStream fStream = new FileStream(@".\Utf8Example.txt", FileMode.Open);
      string contents = null;

      // If file size is small, read in a single operation. 
      if (fStream.Length <= MAX_BUFFER_SIZE) {
         Byte[] bytes = new Byte[fStream.Length];
         fStream.Read(bytes, 0, bytes.Length);
         contents = enc8.GetString(bytes);
      }
      // If file size exceeds buffer size, perform multiple reads. 
      else {
         contents = ReadFromBuffer(fStream);
      }
      fStream.Close();
      Console.WriteLine(contents);
   }

   private static string ReadFromBuffer(FileStream fStream)
   {
        Byte[] bytes = new Byte[MAX_BUFFER_SIZE];
        string output = String.Empty;
        Decoder decoder8 = enc8.GetDecoder();

        while (fStream.Position < fStream.Length) {
           int nBytes = fStream.Read(bytes, 0, bytes.Length);
           int nChars = decoder8.GetCharCount(bytes, 0, nBytes);
           char[] chars = new char[nChars];
           nChars = decoder8.GetChars(bytes, 0, nBytes, chars, 0);
           output += new String(chars, 0, nChars);                                                     
        }
        return output;
    }
}
// The example displays the following output: 
//     This is a UTF-8-encoded file that contains primarily Latin text, although it 
//     does list the first twelve letters of the Russian (Cyrillic) alphabet: 
//      
//     А б в г д е ё ж з и й к 
//      
//     The goal is to save this file, then open and decode it as a binary stream.

The example uses the following text, which should be saved to a UTF-8 encoded file named Utf8Example.txt.

This is a UTF-8-encoded file that contains primarily Latin text, although it 
does list the first twelve letters of the Russian (Cyrillic) alphabet:

А б в г д е ё ж з и й к

The goal is to save this file, then open and decode it as a binary stream.

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1

.NET Framework Client Profile

Supported in: 4, 3.5 SP1
Show:
© 2015 Microsoft