Как преобразовать UTF-8 byte [] в строку?

У меня есть byte[]массив, который загружается из файла, который, как мне известно, содержит UTF-8 .

В некотором отладочном коде мне нужно преобразовать его в строку. Есть ли один лайнер, который сделает это?

Под обложками должно быть только выделение и мемкопия , поэтому, даже если это не реализовано, это должно быть возможно.

string result = System.Text.Encoding.UTF8.GetString(byteArray);

Есть как минимум четыре разных способа сделать это преобразование.

1. Кодирует GetString
   , но вы не сможете вернуть исходные байты, если эти байты имеют символы не ASCII.

2. BitConverter.ToString
   Выходные данные представляют собой строку с разделителем «-», но нет встроенного метода .NET для преобразования строки обратно в байтовый массив.

3. Convert.ToBase64String
   Вы можете легко преобразовать выходную строку обратно в байтовый массив, используя Convert.FromBase64String.
   Примечание. Выходная строка может содержать «+», «/» и «=». Если вы хотите использовать строку в URL, вам необходимо явно ее кодировать.

4. HttpServerUtility.UrlTokenEncode
   Вы можете легко преобразовать выходную строку обратно в байтовый массив, используя HttpServerUtility.UrlTokenDecode. Выходная строка уже совместима с URL! Недостатком является необходимость System.Webсборки, если ваш проект не является веб-проектом.

Полный пример:

byte[] bytes = { 130, 200, 234, 23 }; // A byte array contains non-ASCII (or non-readable) characters

string s1 = Encoding.UTF8.GetString(bytes); // ���
byte[] decBytes1 = Encoding.UTF8.GetBytes(s1);  // decBytes1.Length == 10 !!
// decBytes1 not same as bytes
// Using UTF-8 or other Encoding object will get similar results

string s2 = BitConverter.ToString(bytes);   // 82-C8-EA-17
String[] tempAry = s2.Split('-');
byte[] decBytes2 = new byte[tempAry.Length];
for (int i = 0; i < tempAry.Length; i++)
    decBytes2[i] = Convert.ToByte(tempAry[i], 16);
// decBytes2 same as bytes

string s3 = Convert.ToBase64String(bytes);  // gsjqFw==
byte[] decByte3 = Convert.FromBase64String(s3);
// decByte3 same as bytes

string s4 = HttpServerUtility.UrlTokenEncode(bytes);    // gsjqFw2
byte[] decBytes4 = HttpServerUtility.UrlTokenDecode(s4);
// decBytes4 same as bytes

Общее решение для преобразования байтового массива в строку, когда вы не знаете кодировку:

static string BytesToStringConverted(byte[] bytes)
{
    using (var stream = new MemoryStream(bytes))
    {
        using (var streamReader = new StreamReader(stream))
        {
            return streamReader.ReadToEnd();
        }
    }
}

Определение:

public static string ConvertByteToString(this byte[] source)
{
    return source != null ? System.Text.Encoding.UTF8.GetString(source) : null;
}

С помощью:

string result = input.ConvertByteToString();

Преобразование byte[]в a stringкажется простым, но любой вид кодирования может испортить выходную строку. Эта маленькая функция просто работает без каких-либо неожиданных результатов:

private string ToString(byte[] bytes)
{
    string response = string.Empty;

    foreach (byte b in bytes)
        response += (Char)b;

    return response;
}

Использование (byte)b.ToString("x2"), Выходыb4b5dfe475e58b67

public static class Ext {

    public static string ToHexString(this byte[] hex)
    {
        if (hex == null) return null;
        if (hex.Length == 0) return string.Empty;

        var s = new StringBuilder();
        foreach (byte b in hex) {
            s.Append(b.ToString("x2"));
        }
        return s.ToString();
    }

    public static byte[] ToHexBytes(this string hex)
    {
        if (hex == null) return null;
        if (hex.Length == 0) return new byte[0];

        int l = hex.Length / 2;
        var b = new byte[l];
        for (int i = 0; i < l; ++i) {
            b[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
        }
        return b;
    }

    public static bool EqualsTo(this byte[] bytes, byte[] bytesToCompare)
    {
        if (bytes == null && bytesToCompare == null) return true; // ?
        if (bytes == null || bytesToCompare == null) return false;
        if (object.ReferenceEquals(bytes, bytesToCompare)) return true;

        if (bytes.Length != bytesToCompare.Length) return false;

        for (int i = 0; i < bytes.Length; ++i) {
            if (bytes[i] != bytesToCompare[i]) return false;
        }
        return true;
    }

}

Существует также класс UnicodeEncoding, довольно простой в использовании:

ByteConverter = new UnicodeEncoding();
string stringDataForEncoding = "My Secret Data!";
byte[] dataEncoded = ByteConverter.GetBytes(stringDataForEncoding);

Console.WriteLine("Data after decoding: {0}", ByteConverter.GetString(dataEncoded));

В качестве альтернативы:

 var byteStr = Convert.ToBase64String(bytes);

Однострочный Linq для преобразования байтового массива, byteArrFilenameсчитанного из файла, в чистую строку с нулевым окончанием в стиле ascii C будет выглядеть так: Удобно для чтения таких вещей, как таблицы индексов файлов в старых форматах архивов.

String filename = new String(byteArrFilename.TakeWhile(x => x != 0)
                              .Select(x => x < 128 ? (Char)x : '?').ToArray());

Я использую в '?'качестве значения по умолчанию char для чего-то не чистого ascii, но это, конечно, можно изменить. Если вы хотите быть уверены, что можете обнаружить его, просто используйте '\0'вместо этого, так как TakeWhileв начале гарантирует, что строка, построенная таким образом, не может содержать '\0'значения из входного источника.

BitConverterкласс может быть использован для преобразования byte[]в string.

var convertedString = BitConverter.ToString(byteAttay);

Документация BitConverterкласса может быть найдена на MSDN

Насколько мне известно, ни один из приведенных ответов не гарантирует правильного поведения с нулевым завершением. Пока кто-то не показывает мне по-другому, я написал свой собственный статический класс для обработки этого с помощью следующих методов:

// Mimics the functionality of strlen() in c/c++
// Needed because niether StringBuilder or Encoding.*.GetString() handle \0 well
static int StringLength(byte[] buffer, int startIndex = 0)
{
    int strlen = 0;
    while
    (
        (startIndex + strlen + 1) < buffer.Length // Make sure incrementing won't break any bounds
        && buffer[startIndex + strlen] != 0       // The typical null terimation check
    )
    {
        ++strlen;
    }
    return strlen;
}

// This is messy, but I haven't found a built-in way in c# that guarentees null termination
public static string ParseBytes(byte[] buffer, out int strlen, int startIndex = 0)
{
    strlen = StringLength(buffer, startIndex);
    byte[] c_str = new byte[strlen];
    Array.Copy(buffer, startIndex, c_str, 0, strlen);
    return Encoding.UTF8.GetString(c_str);
}

Причина startIndexбыла в примере, над которым я работал конкретно, мне нужно было проанализировать byte[]массив как массив строк с нулевым символом в конце. Это может быть безопасно проигнорировано в простом случае

hier - это результат, когда вам не нужно было беспокоиться о кодировке. Я использовал его в своем сетевом классе и отправлял двоичные объекты в виде строки с ним.

        public static byte[] String2ByteArray(string str)
        {
            char[] chars = str.ToArray();
            byte[] bytes = new byte[chars.Length * 2];

            for (int i = 0; i < chars.Length; i++)
                Array.Copy(BitConverter.GetBytes(chars[i]), 0, bytes, i * 2, 2);

            return bytes;
        }

        public static string ByteArray2String(byte[] bytes)
        {
            char[] chars = new char[bytes.Length / 2];

            for (int i = 0; i < chars.Length; i++)
                chars[i] = BitConverter.ToChar(bytes, i * 2);

            return new string(chars);
        }

В дополнение к выбранному ответу, если вы используете .NET35 или .NET35 CE, вы должны указать индекс первого байта для декодирования и количество байтов для декодирования:

string result = System.Text.Encoding.UTF8.GetString(byteArray,0,byteArray.Length);

Попробуйте это консольное приложение:

static void Main(string[] args)
{
    //Encoding _UTF8 = Encoding.UTF8;
    string[] _mainString = { "Héllo World" };
    Console.WriteLine("Main String: " + _mainString);

    //Convert a string to utf-8 bytes.
    byte[] _utf8Bytes = Encoding.UTF8.GetBytes(_mainString[0]);

    //Convert utf-8 bytes to a string.
    string _stringuUnicode = Encoding.UTF8.GetString(_utf8Bytes);
    Console.WriteLine("String Unicode: " + _stringuUnicode);
}

Я видел некоторые ответы в этом посте, и это можно считать законченным базовым знанием, потому что есть несколько подходов в программировании на C # для решения той же проблемы. Единственное, что необходимо учитывать, - это разница между Pure UTF-8 и UTF-8 с BOM .

На прошлой неделе, на моей работе, мне нужно было разработать одну функциональность, которая выводит файлы CSV с BOM и другие CSV с чистым UTF-8 (без BOM), каждый тип кодировки файла CSV будет использоваться различными нестандартизированными API, API читает UTF-8 с спецификацией, а другой API читает без спецификации. Мне нужно изучить ссылки на эту концепцию, читая «В чем разница между UTF-8 и UTF-8 без спецификации? », Обсуждение стека переполнения и эту ссылку в Википедии « Порядок следования байтов », чтобы построить мой подход.

Наконец, мое программирование на C # для обоих типов кодирования UTF-8 (с BOM и pure) должно быть примерно таким, как в следующем примере:

//for UTF-8 with B.O.M., equals shared by Zanoni (at top)
string result = System.Text.Encoding.UTF8.GetString(byteArray);

//for Pure UTF-8 (without B.O.M.)
string result = (new UTF8Encoding(false)).GetString(byteArray);

static string BytesToStringConverted(byte[] bytes)
{
    using (var stream = new MemoryStream(bytes))
    {
        using (var streamReader = new StreamReader(stream))
        {
            return streamReader.ReadToEnd();
        }
    }
}