Как получить согласованное байтовое представление строк в C # без указания кодировки вручную?

Как преобразовать stringк byte[]в .NET (C #), вручную указав конкретную кодировку?

Я собираюсь зашифровать строку. Я могу зашифровать его без конвертации, но я все же хотел бы знать, почему здесь играет роль кодировка.

Кроме того, почему кодирование должно быть принято во внимание? Разве я не могу просто получить, в каких байтах хранится строка? Почему существует зависимость от кодировки символов?

23.01.2009 13:39:54
Каждая строка хранится как массив байтов, верно? Почему я не могу просто получить эти байты?
Agnel Kurian 23.01.2009 14:05:26
Кодировка - это то, что отображает символы в байты. Например, в ASCII буква «А» соответствует номеру 65. В другой кодировке она может не совпадать. Однако высокоуровневый подход к строкам, принятым в .NET Framework, делает это в значительной степени неактуальным (за исключением этого случая).
Lucas Jones 13.04.2009 14:13:49
Чтобы играть адвокат дьявола: Если вы хотите получить байты строки в памяти (как .NET использует их) и каким-либо образом манипулировать ими (например, CRC32), и НИКОГДА не хотел декодировать его обратно в исходную строку ... это Не понятно, почему вы заботитесь о кодировках или о том, какой вариант выбрать.
Greg 1.12.2009 19:47:38
Удивлен, никто еще не дал эту ссылку: joelonsoftware.com/articles/Unicode.html
Bevan 29.06.2010 02:57:28
Символ - это не байт, а байт - это не символ. Символ - это и ключ к таблице шрифтов, и лексическая традиция. Строка - это последовательность символов. (Слова, абзацы, предложения и названия также имеют свои собственные лексические традиции, которые оправдывают их собственные определения типов - но я отвлекся). Как и целые числа, числа с плавающей точкой и все остальное, символы кодируются в байты. Было время, когда кодировка была проста один в один: ASCII. Однако, чтобы приспособить всю человеческую символику, 256 перестановок байта были недостаточны, и были разработаны кодировки, чтобы выборочно использовать больше байтов.
George 28.08.2014 15:43:16
30 ОТВЕТОВ
РЕШЕНИЕ

Вопреки ответам здесь, вам не нужно беспокоиться о кодировании, если байты не нужно интерпретировать!

Как вы упомянули, ваша цель - просто «получить, в каких байтах хранится строка» .
(И, конечно же, чтобы можно было восстановить строку из байтов.)

Для этих целей я, честно говоря, не понимаю, почему люди продолжают говорить вам, что вам нужны кодировки. Вам, конечно, не нужно беспокоиться о кодировках для этого.

Просто сделайте это вместо этого:

static byte[] GetBytes(string str)
{
    byte[] bytes = new byte[str.Length * sizeof(char)];
    System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
    return bytes;
}

// Do NOT use on arbitrary bytes; only use on GetBytes's output on the SAME system
static string GetString(byte[] bytes)
{
    char[] chars = new char[bytes.Length / sizeof(char)];
    System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
    return new string(chars);
}

До тех пор, пока ваша программа (или другие программы) не пытаются как-то интерпретировать байты, что вы явно не упомянули, что собираетесь делать, в этом нет ничего плохого! Беспокойство по поводу кодировок просто усложняет вашу жизнь без реальной причины.

Дополнительное преимущество этого подхода:

Не имеет значения, содержит ли строка недопустимые символы, потому что вы все равно можете получить данные и восстановить исходную строку!

Он будет закодирован и декодирован точно так же, потому что вы просто смотрите на байты .

Однако, если бы вы использовали определенную кодировку, это привело бы к проблемам с кодированием / декодированием недопустимых символов.

1852
3.06.2019 20:34:01
Что некрасиво об этом один в том, что GetStringи GetBytesнужно выполняться на системе с одной и той же работы на порядок байтов. Таким образом, вы не можете использовать это, чтобы получить байты, которые вы хотите превратить в строку в другом месте. Поэтому мне трудно придумывать ситуации, в которых я хотел бы использовать это.
CodesInChaos 13.05.2012 11:14:52
@CodeInChaos: Как я уже сказал, весь смысл в том, если вы хотите использовать его в той же системе, с тем же набором функций. Если нет, то вы не должны его использовать.
user541686 13.05.2012 18:00:27
-1 Я гарантирую, что кто-то (кто не понимает байты против символов) захочет преобразовать свою строку в байтовый массив, он будет гуглить и читать этот ответ, и он будет делать неправильные вещи, потому что почти во всех случаи, кодирование IS актуальны.
artbristol 15.06.2012 11:07:20
@artbristol: Если они не могут потрудиться прочитать ответ (или другие ответы ...), тогда извините, тогда для меня нет лучшего способа общаться с ними. Обычно я предпочитаю отвечать на ФП, а не пытаться угадать, что другие могут сделать с моим ответом - ФП имеет право знать, и то, что кто-то может злоупотреблять ножом, не означает, что нам нужно спрятать все ножи в мире. для себя. Хотя, если вы не согласны, это тоже хорошо.
user541686 15.06.2012 14:04:28
Этот ответ неверен на многих уровнях, но в первую очередь из-за того, что он гласит: «Вам не нужно беспокоиться о кодировании!». Два метода, GetBytes и GetString, излишни в той мере, в какой они просто являются повторными реализациями того, что уже делают Encoding.Unicode.GetBytes () и Encoding.Unicode.GetString (). Утверждение «Пока ваша программа (или другие программы) не пытаются интерпретировать байты» также в корне ошибочно, поскольку неявно они означают, что байты должны интерпретироваться как Unicode.
David 11.07.2012 12:36:17
byte[] strToByteArray(string str)
{
    System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
    return enc.GetBytes(str);
}
17
23.01.2009 13:43:18
Но почему следует учитывать кодировку? Почему я не могу просто получить байты, не видя, какая кодировка используется? Даже если бы это было необходимо, разве сам объект String не должен знать, какая кодировка используется, и просто выгружать то, что находится в памяти?
Agnel Kurian 23.01.2009 13:46:40
Это не всегда работает. Некоторые специальные символы могут быть потеряны при использовании такого метода, который я нашел трудным путем.
JB King 23.01.2009 17:14:16

Это зависит от кодировки вашей строки ( ASCII , UTF-8 , ...).

Например:

byte[] b1 = System.Text.Encoding.UTF8.GetBytes (myString);
byte[] b2 = System.Text.Encoding.ASCII.GetBytes (myString);

Небольшой пример, почему кодирование имеет значение:

string pi = "\u03a0";
byte[] ascii = System.Text.Encoding.ASCII.GetBytes (pi);
byte[] utf8 = System.Text.Encoding.UTF8.GetBytes (pi);

Console.WriteLine (ascii.Length); //Will print 1
Console.WriteLine (utf8.Length); //Will print 2
Console.WriteLine (System.Text.Encoding.ASCII.GetString (ascii)); //Will print '?'

ASCII просто не оборудован для работы со специальными символами.

Внутренне .NET Framework использует UTF-16 для представления строк, поэтому, если вы просто хотите получить точные байты, которые использует .NET, используйте System.Text.Encoding.Unicode.GetBytes (...).

См. Кодировка символов в .NET Framework (MSDN) для получения дополнительной информации.

1108
24.04.2015 09:52:05
Но почему следует учитывать кодировку? Почему я не могу просто получить байты, не видя, какая кодировка используется? Даже если бы это было необходимо, разве сам объект String не должен знать, какая кодировка используется, и просто выгружать то, что находится в памяти?
Agnel Kurian 23.01.2009 13:48:26
Строки .NET всегда кодируются как Unicode. Так что используйте System.Text.Encoding.Unicode.GetBytes (); чтобы получить набор байтов, который .NET использовал бы для представления символов. Однако зачем вам это? Я рекомендую UTF-8, особенно когда большинство символов в западном латинском наборе.
AnthonyWJones 23.01.2009 14:33:29
Кроме того: точные байты, используемые внутри строки, не имеют значения, если система, которая их получает, не обрабатывает эту кодировку или обрабатывает ее как неправильную кодировку. Если это все в .Net, зачем вообще конвертировать в массив байтов. В противном случае лучше указывать кодировку явно
Joel Coehoorn 23.01.2009 15:42:16
@Joel, будьте осторожны с System.Text.Encoding.Default, так как он может отличаться на каждой машине, на которой он запущен. Вот почему рекомендуется всегда указывать кодировку, например UTF-8.
Ash 28.01.2010 09:01:16
Вам не нужны кодировки, если только вы (или кто-то еще) не намереваетесь интерпретировать данные вместо того, чтобы рассматривать их как общий «блок байтов». Для таких вещей, как сжатие, шифрование и т. Д., Беспокоиться о кодировке не имеет смысла. Смотрите мой ответ, чтобы узнать, как это сделать, не беспокоясь о кодировке. (Я мог бы дать -1 за то, что сказал, что вам нужно беспокоиться о кодировках, когда вы этого не делаете, но я не чувствую себя сегодня особенно
user541686 30.04.2012 07:55:05
// C# to convert a string to a byte array.
public static byte[] StrToByteArray(string str)
{
    System.Text.ASCIIEncoding  encoding=new System.Text.ASCIIEncoding();
    return encoding.GetBytes(str);
}


// C# to convert a byte array to a string.
byte [] dBytes = ...
string str;
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
str = enc.GetString(dBytes);
-2
23.01.2009 13:43:58
1) Это приведет к потере данных из-за использования ASCII в качестве кодировки. 2) Нет смысла создавать новое ASCIIEncoding - просто используйте свойство Encoding.ASCII.
Jon Skeet 27.01.2009 06:35:53

Необходимо принять во внимание кодировку, потому что 1 символ может быть представлен 1 или более байтами (до 6), и разные кодировки будут обрабатывать эти байты по-разному.

У Джоэла есть пост на эту тему:

Абсолютный минимум Каждый разработчик программного обеспечения должен абсолютно точно знать о Unicode и наборах символов (никаких оправданий!)

95
23.01.2009 14:03:30
«1 символ может быть представлен 1 или более байтами» Я согласен. Я просто хочу эти байты независимо от того, в какой кодировке находится строка. Единственный способ сохранить строку в памяти - это байты. Четные символы хранятся как 1 или более байтов. Я просто хочу получить в свои руки эти байты.
Agnel Kurian 23.01.2009 14:07:26
Вам не нужны кодировки, если только вы (или кто-то еще) не намереваетесь интерпретировать данные вместо того, чтобы рассматривать их как общий «блок байтов». Для таких вещей, как сжатие, шифрование и т. Д., Беспокоиться о кодировке не имеет смысла. Смотрите мой ответ, чтобы узнать, как это сделать, не беспокоясь о кодировке.
user541686 30.04.2012 07:54:23
@Mehrdad - В общем, но первоначальный вопрос, как было сказано, когда я первоначально отвечал, не уточнил, что OP будет происходить с этими байтами после того, как они их преобразовали, и для будущих поисковиков информация, которая уместна - это довольно хорошо охвачен ответом Джоэла - и как вы утверждаете в своем ответе: при условии, что вы остаетесь в мире .NET и используете свои методы для преобразования в / из, вы счастливы. Как только вы выйдете за пределы этого, кодирование будет иметь значение.
Zhaph - Ben Duguid 30.04.2012 10:48:26
Одна кодовая точка может быть представлена ​​до 4 байтов. (Одна кодовая единица UTF-32, суррогатная пара UTF-16 или 4 байта UTF-8.) Значения, для которых UTF-8 потребуется более 4 байтов, находятся вне диапазона Unicode 0x0..0x10FFFF. ;-)
DevSolar 8.10.2018 15:05:09

Ключевой вопрос заключается в том, что глиф в строке занимает 32 бита (16 битов для кода символа), но для байта требуется только 8 бит. Сопоставление один к одному не существует, если вы не ограничиваете себя строками, которые содержат только символы ASCII. System.Text.Encoding имеет много способов отобразить строку в byte [], вам нужно выбрать такую, которая позволяет избежать потери информации и которая проста в использовании вашим клиентом, когда ему нужно отобразить byte [] обратно в строку ,

Utf8 - это популярная кодировка, она компактная и без потерь.

10
23.01.2009 14:15:26
UTF-8 компактен, только если большинство ваших символов в наборе символов английского языка (ASCII). Если бы у вас была длинная строка китайских символов, UTF-16 была бы более компактной кодировкой, чем UTF-8 для этой строки. Это связано с тем, что UTF-8 использует один байт для кодирования ASCII и 3 (или, возможно, 4) в противном случае.
Joel Mueller 23.01.2009 20:40:59
Правда. Но как вы можете не знать о кодировании, если вы знакомы с обработкой китайского текста?
Hans Passant 24.01.2009 03:40:31

Я не уверен, но я думаю, что строка хранит свою информацию в виде массива символов, что неэффективно с байтами. В частности, определение Char является «Представляет символ Unicode».

возьмите пример этого примера:

String str = "asdf éß";
String str2 = "asdf gh";
EncodingInfo[] info =  Encoding.GetEncodings();
foreach (EncodingInfo enc in info)
{
    System.Console.WriteLine(enc.Name + " - " 
      + enc.GetEncoding().GetByteCount(str)
      + enc.GetEncoding().GetByteCount(str2));
}

Обратите внимание, что ответ Unicode в обоих случаях составляет 14 байтов, тогда как ответ UTF-8 составляет только 9 байтов для первого и только 7 для второго.

Поэтому, если вы просто хотите, чтобы байты использовались строкой, просто используйте Encoding.Unicode, но это будет неэффективно с пространством хранения.

13
12.08.2016 18:38:55

На первую часть вашего вопроса (как получить байты) уже отвечали другие: посмотрите в System.Text.Encodingпространство имен.

Я отвечу на ваш следующий вопрос: зачем вам выбирать кодировку? Почему вы не можете получить это из самого строкового класса?

Ответ состоит из двух частей.

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

Если ваша программа полностью находится в мире .Net, вам не нужно беспокоиться о получении байтовых массивов для строк, даже если вы отправляете данные по сети. Вместо этого используйте .Net Serialization, чтобы беспокоиться о передаче данных. Вы больше не беспокоитесь о реальных байтах: средство форматирования Serialization сделает это за вас.

С другой стороны, что, если вы отправляете эти байты куда-то, что, как вы не можете гарантировать, извлечет данные из сериализованного потока .Net? В этом случае вам определенно нужно беспокоиться о кодировании, потому что, очевидно, эта внешняя система заботится. Итак, еще раз, внутренние байты, используемые строкой, не имеют значения: вам нужно выбрать кодировку, чтобы вы могли четко указать эту кодировку на принимающей стороне, даже если это та же кодировка, которая используется внутри .Net.

Я понимаю, что в этом случае вы могли бы предпочесть использовать фактические байты, сохраненные строковой переменной в памяти, где это возможно, с идеей, что это может сэкономить некоторую работу, создавая ваш поток байтов. Тем не менее, я говорю вам, что это просто не важно по сравнению с тем, чтобы убедиться, что ваш вывод понят на другом конце, и чтобы гарантировать, что вы должны четко указывать свою кодировку. Кроме того, если вы действительно хотите сопоставить свои внутренние байты, вы уже можете просто выбрать Unicodeкодировку и получить эту экономию производительности.

Это подводит меня ко второй части ... выбирая Unicodeкодирование будет говорить .Net , чтобы использовать основные байты. Вам нужно выбрать эту кодировку, потому что когда выходит какой-то новый Unicode-Plus, среда выполнения .Net должна быть свободна, чтобы использовать эту более новую, лучшую модель кодирования, не ломая вашу программу. Но на данный момент (и в обозримом будущем) простой выбор кодировки Unicode даст вам то, что вы хотите.

Также важно понимать, что ваша строка должна быть перезаписана на провод, и это предполагает, по крайней мере, некоторый перевод битового шаблона, даже если вы используете соответствующую кодировку . Компьютер должен учитывать такие вещи, как Big против Little Endian, порядок байтов в сети, пакетирование, информация о сеансе и т. Д.

46
25.09.2017 21:13:44
В .NET есть области, где вам нужно получить байтовые массивы для строк. Многие из классов .NET Cryptrography содержат такие методы, как ComputeHash (), которые принимают байтовый массив или поток. У вас нет другого выбора, кроме как сначала преобразовать строку в байтовый массив (выбирая кодировку), а затем, при желании, обернуть ее в поток. Однако до тех пор, пока вы выбираете кодировку (то есть UTF8), придерживайтесь ее, с этим проблем не возникает.
Ash 28.01.2010 09:33:21
BinaryFormatter bf = new BinaryFormatter();
byte[] bytes;
MemoryStream ms = new MemoryStream();

string orig = "喂 Hello 谢谢 Thank You";
bf.Serialize(ms, orig);
ms.Seek(0, 0);
bytes = ms.ToArray();

MessageBox.Show("Original bytes Length: " + bytes.Length.ToString());

MessageBox.Show("Original string Length: " + orig.Length.ToString());

for (int i = 0; i < bytes.Length; ++i) bytes[i] ^= 168; // pseudo encrypt
for (int i = 0; i < bytes.Length; ++i) bytes[i] ^= 168; // pseudo decrypt

BinaryFormatter bfx = new BinaryFormatter();
MemoryStream msx = new MemoryStream();            
msx.Write(bytes, 0, bytes.Length);
msx.Seek(0, 0);
string sx = (string)bfx.Deserialize(msx);

MessageBox.Show("Still intact :" + sx);

MessageBox.Show("Deserialize string Length(still intact): " 
    + sx.Length.ToString());

BinaryFormatter bfy = new BinaryFormatter();
MemoryStream msy = new MemoryStream();
bfy.Serialize(msy, sx);
msy.Seek(0, 0);
byte[] bytesy = msy.ToArray();

MessageBox.Show("Deserialize bytes Length(still intact): " 
   + bytesy.Length.ToString());
115
26.01.2009 06:29:52
Вы можете использовать один и тот же экземпляр BinaryFormatter для всех этих операций
Joel Coehoorn 23.01.2009 17:25:59
Очень интересно. По-видимому, это исключит любой высокий суррогатный символ Unicode. См. Документацию по [BinaryFormatter ]
user334911 18.11.2010 18:51:45

Два пути:

public static byte[] StrToByteArray(this string s)
{
    List<byte> value = new List<byte>();
    foreach (char c in s.ToCharArray())
        value.Add(c.ToByte());
    return value.ToArray();
}

А также,

public static byte[] StrToByteArray(this string s)
{
    s = s.Replace(" ", string.Empty);
    byte[] buffer = new byte[s.Length / 2];
    for (int i = 0; i < s.Length; i += 2)
        buffer[i / 2] = (byte)Convert.ToByte(s.Substring(i, 2), 16);
    return buffer;
}

Я склонен использовать нижнюю чаще, чем верхнюю, не оценивая их по скорости.

1
19.02.2009 21:03:34
А как насчет многобайтовых символов?
Agnel Kurian 23.02.2009 09:57:52
c.ToByte () является приватным: S
Khodor 20.06.2011 08:41:54
@AgnelKurian Msdn говорит: «Этот метод возвращает беззнаковое значение байта, которое представляет числовой код объекта Char, переданного ему. В .NET Framework объект Char является 16-разрядным значением. Это означает, что метод подходит для возврата числовые коды символов в диапазоне символов ASCII или в элементах управления Unicode C0 и базовой латинице, а также в диапазонах управления C1 и Latin-1, от U + 0000 до U + 00FF. "
mg30rg 11.01.2018 11:30:25

Также, пожалуйста, объясните, почему следует учитывать кодировку. Разве я не могу просто получить, в каких байтах хранится строка? Почему эта зависимость от кодирования? !!!

Потому что нет такой вещи как «байты строки».

Строка (или, в более общем смысле, текст) состоит из символов: букв, цифр и других символов. Это все. Компьютеры, однако, ничего не знают о персонажах; они могут обрабатывать только байты. Поэтому, если вы хотите сохранить или передать текст с помощью компьютера, вам необходимо преобразовать символы в байты. Как ты это делаешь? Вот где кодировки приходят на сцену.

Кодировка - это не что иное, как соглашение о переводе логических символов в физические байты. Самая простая и известная кодировка - ASCII, и это все, что вам нужно, если вы пишете на английском языке. Для других языков вам потребуются более полные кодировки, так как любой из вариантов Unicode является самым безопасным выбором на сегодняшний день.

Короче говоря, попытка «получить байты строки без использования кодировок» так же невозможна, как «запись текста без использования какого-либо языка».

Кстати, я настоятельно рекомендую вам (и любому, в этом отношении) прочитать эту маленькую мудрость: Абсолютный минимум, который должен быть у каждого разработчика программного обеспечения.

23
23.10.2015 06:19:47
Позвольте мне уточнить: кодировка использовалась для перевода «привет мира» в физические байты. Поскольку строка хранится на моем компьютере, я уверен, что она должна храниться в байтах. Я просто хочу получить доступ к этим байтам, чтобы сохранить их на диске или по любой другой причине. Я не хочу интерпретировать эти байты. Поскольку я не хочу интерпретировать эти байты, необходимость в кодировке на этом этапе столь же неуместна, как и необходимость в телефонной линии для вызова printf.
Agnel Kurian 16.07.2009 15:30:48
Но опять же, нет концепции преобразования текста в физические байты, если только вы не используете кодировку. Конечно, компилятор каким-то образом хранит строки в памяти - но он просто использует внутреннюю кодировку, которую вы (или кто-либо, кроме разработчика компилятора) не знаете. Итак, что бы вы ни делали, вам нужна кодировка для получения физических байтов из строки.
Konamiman 22.07.2009 08:35:39
@Annel Kurian: Конечно, у строки есть куча байтов, в которых хранится ее содержимое (UTF-16 в воздухе). Но есть веская причина помешать вам получить к нему доступ: строки являются неизменяемыми, и если вы можете получить внутренний массив byte [], вы также можете изменить его. Это нарушает неизменность, что крайне важно, поскольку несколько строк могут совместно использовать одни и те же данные. Использование кодировки UTF-16 для получения строки, вероятно, просто скопирует данные.
ollb 14.05.2011 00:06:56
@ Gnafoo, копия байтов подойдет.
Agnel Kurian 14.05.2011 05:06:15

Самый быстрый способ

public static byte[] GetBytes(string text)
{
    return System.Text.ASCIIEncoding.UTF8.GetBytes(text);
}

РЕДАКТИРОВАТЬ, как прокомментировал Макотосан, теперь это лучший способ:

Encoding.UTF8.GetBytes(text)
8
4.08.2016 10:31:17
ASCIIEncoding ..... не требуется. Простое использование Encoding.UTF8.GetBytes (текст) является предпочтительным.
Makotosan 17.02.2012 20:40:25

Ну, я прочитал все ответы, и они были об использовании кодировки или о сериализации, которая отбрасывает непарные суррогаты.

Плохо, когда строка, например, исходит от SQL Server, где она была построена из байтового массива, например, хэша пароля. Если мы отбросим что-либо из него, он сохранит недопустимый хеш, и если мы хотим сохранить его в XML, мы хотим оставить его нетронутым (поскольку средство записи XML удаляет исключение для любого найденного непарного суррогата).

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

public static byte[] StringToBytes(string str)
{
    byte[] data = new byte[str.Length * 2];
    for (int i = 0; i < str.Length; ++i)
    {
        char ch = str[i];
        data[i * 2] = (byte)(ch & 0xFF);
        data[i * 2 + 1] = (byte)((ch & 0xFF00) >> 8);
    }

    return data;
}

public static string StringFromBytes(byte[] arr)
{
    char[] ch = new char[arr.Length / 2];
    for (int i = 0; i < ch.Length; ++i)
    {
        ch[i] = (char)((int)arr[i * 2] + (((int)arr[i * 2 + 1]) << 8));
    }
    return new String(ch);
}
25
9.03.2017 08:55:32
Вместо того, чтобы использовать свой собственный метод для преобразования байтового массива в base64, все, что вам нужно было сделать, это использовать встроенный конвертер: Convert.ToBase64String (arr);
Makotosan 10.02.2012 15:53:36
@Makotosan спасибо, но я использовал Convert.ToBase64String(arr); для преобразования base64 byte[] (data) <-> string (serialized data to store in XML file). Но , чтобы получить первоначальный byte[] (data)мне нужно сделать что - то с Stringкоторый содержал двоичные данные (это способ MSSQL вернул его мне). Так что функции выше для String (binary data) <-> byte[] (easy accessible binary data).
Gman 6.03.2012 19:15:02

Попробуйте это, намного меньше кода:

System.Text.Encoding.UTF8.GetBytes("TEST String");
40
24.04.2015 09:58:10
Тогда попробуй это System.Text.Encoding.UTF8.GetBytes("Árvíztűrő tükörfúrógép);и плачь! Это будет работать, но System.Text.Encoding.UTF8.GetBytes("Árvíztűrő tükörfúrógép").Length != System.Text.Encoding.UTF8.GetBytes("Arvizturo tukorfurogep").Lengthпока"Árvíztűrő tükörfúrógép".Length == "Arvizturo tukorfurogep".Length
mg30rg 5.12.2017 16:30:19
@ mg30rg: Почему вы думаете, что ваш пример странный? Конечно, в кодировке переменной ширины не все символы имеют одинаковые байтовые длины. Что с этим не так?
Vlad 25.02.2018 01:18:35
@Vlad Более корректный комментарий, однако, заключается в том, что в качестве закодированных символов Юникода (например, байтов) символы, которые содержат свои собственные диакритические знаки, дадут другой результат, чем диакритические знаки, разделенные на символы-модификаторы, добавленные к символу. Но в iirc в .net есть методы, которые специально разделяют их, чтобы получить согласованное представление байтов.
Nyerguds 31.03.2020 12:43:54
bytes[] buffer = UnicodeEncoding.UTF8.GetBytes(string something); //for converting to UTF then get its bytes

bytes[] buffer = ASCIIEncoding.ASCII.GetBytes(string something); //for converting to ascii then get its bytes
1
2.01.2012 11:07:00

Принятый ответ очень и очень сложный. Используйте для этого включенные классы .NET:

const string data = "A string with international characters: Norwegian: ÆØÅæøå, Chinese: 喂 谢谢";
var bytes = System.Text.Encoding.UTF8.GetBytes(data);
var decoded = System.Text.Encoding.UTF8.GetString(bytes);

Не изобретайте велосипед, если вам не нужно ...

283
23.07.2015 14:32:52
В случае, если принятый ответ будет изменен, для целей записи, это ответ Mehrdad в это время и дату. Надеемся, что ОП еще раз займется этим и примет лучшее решение.
Thomas Eding 27.09.2013 18:20:56
в принципе хорошо, но кодировка должна System.Text.Encoding.Unicodeбыть эквивалентна ответу Мерадада.
Jodrell 25.11.2014 09:08:45
Вопрос был отредактирован несколько раз с момента первоначального ответа, так что, возможно, мой ответ немного устарел. Я никогда не намеревался дать преувеличение, эквивалентное ответу Мехрдада, но дать разумный способ сделать это. Но вы можете быть правы. Однако фраза «получить, в каких байтах строка была сохранена» в исходном вопросе очень неточна. Хранится где? В памяти? На диске? Если в памяти, System.Text.Encoding.Unicode.GetBytesвероятно, будет более точным.
Erik A. Brandstadmoen 26.11.2014 11:36:07
@AMissico, ваше предложение содержит ошибки, если только вы не уверены, что ваша строка совместима с кодировкой вашей системы по умолчанию (строка, содержащая только символы ASCII в вашей системной кодировке по умолчанию). Но нигде ОП не заявляет об этом.
Frédéric 6.04.2016 20:53:26
@AMissico Это может привести к тому, что программа даст разные результаты в разных системах . Это никогда не хорошо. Даже если это для создания хэша или чего-то еще (я полагаю, это означает, что OP означает «шифровать»), одна и та же строка всегда должна давать один и тот же хэш.
Nyerguds 22.04.2016 10:33:15

Просто чтобы показать , что звук Mehrdrad в ответ работает, его подход может даже сохраняться непарные символы суррогатных (многие из которых были направлены против моего ответа, но о которых все одинаково виновны, например System.Text.Encoding.UTF8.GetBytes, System.Text.Encoding.Unicode.GetBytesа те методы кодирования не могут сохраняться высокий суррогат d800например, символы , которые просто заменяют старшие суррогатные символы значением fffd):

using System;

class Program
{     
    static void Main(string[] args)
    {
        string t = "爱虫";            
        string s = "Test\ud800Test"; 

        byte[] dumpToBytes = GetBytes(s);
        string getItBack = GetString(dumpToBytes);

        foreach (char item in getItBack)
        {
            Console.WriteLine("{0} {1}", item, ((ushort)item).ToString("x"));
        }    
    }

    static byte[] GetBytes(string str)
    {
        byte[] bytes = new byte[str.Length * sizeof(char)];
        System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
        return bytes;
    }

    static string GetString(byte[] bytes)
    {
        char[] chars = new char[bytes.Length / sizeof(char)];
        System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
        return new string(chars);
    }        
}

Вывод:

T 54
e 65
s 73
t 74
? d800
T 54
e 65
s 73
t 74

Попробуйте это с System.Text.Encoding.UTF8.GetBytes или System.Text.Encoding.Unicode.GetBytes , они просто заменят старшие суррогатные символы значением fffd

Каждый раз, когда в этом вопросе есть движение, я все еще думаю о сериализаторе (будь то от Microsoft или от стороннего компонента), который может сохранять строки, даже если он содержит непарные суррогатные символы; Я гуглю это время от времени: сериализация непарного суррогатного персонажа .NET . Это не заставляет меня терять сон, но это немного раздражает, когда время от времени кто-то комментирует мой ответ, что он ошибочен, но его ответы одинаково несовершенны, когда речь идет о непарных суррогатных персонажах.

Черт, Microsoft должна была просто использовать System.Buffer.BlockCopyв BinaryFormatter

谢谢!

44
23.05.2017 12:18:28
Разве суррогаты не должны появляться в парах, чтобы сформировать правильные кодовые точки? Если это так, я могу понять, почему данные будут искажены.
dtanders 14.06.2012 14:27:32
@dtanders Да, это тоже мои мысли, они должны появляться в парах, непарные суррогатные символы просто случаются, если вы намеренно ставите их в строку и делаете их непарными. Чего я не знаю, так это того, почему другие разработчики продолжают настаивать на том, что мы должны вместо этого использовать подход, учитывающий кодирование, поскольку они считают, что подход сериализации ( мой ответ , который был принят более 3 лет) не оставляет непарных суррогатный персонаж нетронут. Но они забыли проверить, что их решения, поддерживающие кодирование, не сохраняют непарный суррогатный характер, ирония судьбы ツ
Michael Buen 14.06.2012 23:23:30
Если есть библиотека сериализации, которая использует System.Buffer.BlockCopyвнутренне, все аргументы сторонников кодирования будут спорными
Michael Buen 14.06.2012 23:23:58
@MichaelBuen Мне кажется, что главная проблема в том, что вы пишете большими жирными буквами, говоря, что что-то не имеет значения, а не говорите, что это не имеет значения в их случае. В результате вы поощряете людей, которые смотрят на ваш ответ, делать базовые ошибки в программировании, которые в будущем вызовут разочарование других. Непарные суррогаты недопустимы в строке. Это не массив символов, поэтому имеет смысл, что преобразование строки в другой формат приведет к ошибке FFFDв этом символе. Если вы хотите выполнять ручные манипуляции со строками, используйте char [] в соответствии с рекомендациями.
Trisped 11.11.2014 20:06:47
@dtanders: A System.Stringявляется неизменной последовательностью Char; .NET всегда позволяла Stringсоздавать объекты из любого объекта Char[]и экспортировать его содержимое в одно и Char[]то же значение, даже если оригинал Char[]содержит непарные суррогаты.
supercat 12.11.2014 21:57:26

простой код с LINQ

string s = "abc"
byte[] b = s.Select(e => (byte)e).ToArray();

РЕДАКТИРОВАТЬ: как прокомментировано ниже, это не очень хороший способ.

но вы все равно можете использовать его для понимания LINQ с более подходящей кодировкой:

string s = "abc"
byte[] b = s.Cast<byte>().ToArray();
1
18.12.2013 10:13:26
Это чуть быстрее , не говоря уже о самом быстром . Это, конечно, интересная альтернатива, но, по сути, такая же, как и Encoding.Default.GetBytes(s), кстати, намного быстрее . Быстрое тестирование показывает, что Encoding.Default.GetBytes(s)работает как минимум на 79% быстрее. YMMV.
WynandB 25.10.2013 04:36:21
Попробуйте это с . Этот код не потерпит крах, но вернет неправильный результат (что еще хуже). Попробуйте привести к shortвместо того, byteчтобы увидеть разницу.
Hans Kesting 18.12.2013 08:57:07

Вот моя небезопасная реализация Stringдля Byte[]преобразования:

public static unsafe Byte[] GetBytes(String s)
{
    Int32 length = s.Length * sizeof(Char);
    Byte[] bytes = new Byte[length];

    fixed (Char* pInput = s)
    fixed (Byte* pBytes = bytes)
    {
        Byte* source = (Byte*)pInput;
        Byte* destination = pBytes;

        if (length >= 16)
        {
            do
            {
                *((Int64*)destination) = *((Int64*)source);
                *((Int64*)(destination + 8)) = *((Int64*)(source + 8));

                source += 16;
                destination += 16;
            }
            while ((length -= 16) >= 16);
        }

        if (length > 0)
        {
            if ((length & 8) != 0)
            {
                *((Int64*)destination) = *((Int64*)source);

                source += 8;
                destination += 8;
            }

            if ((length & 4) != 0)
            {
                *((Int32*)destination) = *((Int32*)source);

                source += 4;
                destination += 4;
            }

            if ((length & 2) != 0)
            {
                *((Int16*)destination) = *((Int16*)source);

                source += 2;
                destination += 2;
            }

            if ((length & 1) != 0)
            {
                ++source;
                ++destination;

                destination[0] = source[0];
            }
        }
    }

    return bytes;
}

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

[Second String: Length 20]
Buffer.BlockCopy: 746ms
Unsafe: 557ms

[Second String: Length 50]
Buffer.BlockCopy: 861ms
Unsafe: 753ms

[Third String: Length 100]
Buffer.BlockCopy: 1250ms
Unsafe: 1063ms

Чтобы использовать его, вы должны отметить «Разрешить небезопасный код» в свойствах сборки вашего проекта. Согласно .NET Framework 3.5 этот метод также можно использовать как расширение String:

public static unsafe class StringExtensions
{
    public static Byte[] ToByteArray(this String s)
    {
        // Method Code
    }
}
3
12.08.2016 18:38:24
Является ли значение, RuntimeHelpers.OffsetToStringDataкратное 8, в версиях .NET для Itanium? Потому что в противном случае это не удастся из-за невыровненных чтений
Jon Hanna 6.01.2014 14:09:00
не будет ли проще вызвать memcpy? stackoverflow.com/a/27124232/659190
Jodrell 25.11.2014 10:33:45

Вот код:

// Input string.
const string input = "Dot Net Perls";

// Invoke GetBytes method.
// ... You can store this array as a field!
byte[] array = Encoding.ASCII.GetBytes(input);

// Loop through contents of the array.
foreach (byte element in array)
{
    Console.WriteLine("{0} = {1}", element, (char)element);
}
-4
23.01.2013 06:41:24

C # для преобразования stringв byteмассив:

public static byte[] StrToByteArray(string str)
{
   System.Text.UTF8Encoding  encoding=new System.Text.UTF8Encoding();
   return encoding.GetBytes(str);
}
22
12.08.2016 18:39:11

Вы можете использовать следующий код для преобразования stringк byte arrayв .NET

string s_unicode = "abcéabc";
byte[] utf8Bytes = System.Text.Encoding.UTF8.GetBytes(s_unicode);
6
2.05.2014 07:39:30

Вопрос ОП: «Как мне преобразовать stringв byteмассив в .NET (C #)?» [так в оригинале]

Вы можете использовать следующий код:

static byte[] ConvertString (string s) {
    return new byte[0];
}

В качестве преимущества кодирование не имеет значения! Ой, подождите, это экодинация ... это просто тривиально и с большими потерями.

-12
27.09.2013 23:26:41
Это не обращение. Это новый байтовый массив. ОП действительно нужен был указатель и memcpy. Или приведение: byte [] b = (byte []) s ;.
Lodewijk 28.04.2014 12:44:01
Кроме того, «даже» здесь не используется. Определенно не решение.
TechNyquist 14.10.2014 07:18:05

Использование:

    string text = "string";
    byte[] array = System.Text.Encoding.UTF8.GetBytes(text);

Результат:

[0] = 115
[1] = 116
[2] = 114
[3] = 105
[4] = 110
[5] = 103
9
9.01.2017 01:22:07
ОП специально просит НЕ указывать кодировку ... "без указания конкретной кодировки вручную"
Ferdz 30.08.2018 13:40:21

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

Общая потребность

Каждая строка имеет набор символов и кодировку. Когда вы конвертируете System.Stringобъект в массив, у System.Byteвас все равно есть набор символов и кодировка. В большинстве случаев вы будете знать, какой набор символов и кодировки вам нужны, а .NET упрощает «копирование с преобразованием». Просто выберите подходящий Encodingкласс.

// using System.Text;
Encoding.UTF8.GetBytes(".NET String to byte array")

Преобразование может потребоваться для обработки случаев, когда целевой набор символов или кодировка не поддерживает символ, который находится в источнике. У вас есть несколько вариантов: исключение, замена или пропуск. Политика по умолчанию заменяет «?».

// using System.Text;
var text = Encoding.ASCII.GetString(Encoding.ASCII.GetBytes("You win €100")); 
                                                      // -> "You win ?100"

Очевидно, что конверсии не обязательно без потерь!

Примечание: для System.Stringисходного набора символов используется Unicode.

Единственное, что сбивает с толку, - это то, что .NET использует имя набора символов для имени одной конкретной кодировки этого набора символов. Encoding.Unicodeдолжен быть назван Encoding.UTF16.

Вот и все для большинства случаев. Если это то, что вам нужно, перестаньте читать здесь. Посмотрите забавную статью Джоэла Спольски, если вы не понимаете, что такое кодировка.

Конкретная потребность

Теперь автор вопроса спрашивает: «Каждая строка хранится в виде массива байтов, верно? Почему я не могу просто иметь эти байты?»

Он не хочет никакого обращения.

Из спецификации C # :

Обработка символов и строк в C # использует кодировку Unicode. Тип char представляет кодовую единицу UTF-16, а строковый тип представляет последовательность кодовых единиц UTF-16.

Итак, мы знаем, что если мы запросим нулевое преобразование (то есть из UTF-16 в UTF-16), мы получим желаемый результат:

Encoding.Unicode.GetBytes(".NET String to byte array")

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

".NET String to byte array".ToCharArray()

Это не дает нам желаемый тип данных, но ответ Мердада показывает, как преобразовать этот массив Char в байтовый массив с помощью BlockCopy . Тем не менее, это копирует строку дважды! И он слишком явно использует специфичный для кодирования код: тип данных System.Char.

Единственный способ получить фактические байты, в которых хранится строка - это использовать указатель. fixedЗаявление позволяет принимать адрес значений. Из спецификации C #:

[For] выражение типа string ... инициализатор вычисляет адрес первого символа в строке.

Для этого компилятор пишет код, пропускающий другие части строкового объекта с помощью RuntimeHelpers.OffsetToStringData. Итак, чтобы получить необработанные байты, просто создайте указатель на строку и скопируйте необходимое количество байтов.

// using System.Runtime.InteropServices
unsafe byte[] GetRawBytes(String s)
{
    if (s == null) return null;
    var codeunitCount = s.Length;
    /* We know that String is a sequence of UTF-16 codeunits 
       and such codeunits are 2 bytes */
    var byteCount = codeunitCount * 2; 
    var bytes = new byte[byteCount];
    fixed(void* pRaw = s)
    {
        Marshal.Copy((IntPtr)pRaw, bytes, 0, byteCount);
    }
    return bytes;
}

Как указал @CodesInChaos, результат зависит от порядкового номера машины. Но автора вопроса это не касается.

88
23.05.2017 10:31:37
В общем случае некорректно устанавливать byteCountудвоенную длину строки. Для кодовых точек Unicode вне Базовой многоязычной плоскости для каждого символа будут две 16-битные кодовые единицы.
Jan Hettich 4.02.2014 02:33:44
@Jan Это правильно, но длина строки уже дает количество кодовых единиц (не кодовых точек).
Tom Blodget 4.02.2014 02:35:29
Спасибо что подметил это! Из MSDN: « LengthСвойство [of String] возвращает количество Charобъектов в этом экземпляре, а не количество символов Unicode». Ваш пример кода, следовательно, правильно, как написано.
Jan Hettich 4.02.2014 05:42:50
@TomBlodget: Интересно, что если брать экземпляры Globalization.SortKey, извлекать KeyDataи упаковывать результирующие байты из каждого в String[два байта на символ, сначала MSB ], вызов String.CompareOrdinalрезультирующих строк будет существенно быстрее, чем вызов SortKey.Compareэкземпляров SortKey, или даже призывая memcmpк этим случаям. Учитывая это, мне интересно, почему KeyDataвозвращается, Byte[]а не String?
supercat 13.11.2014 17:56:04
@TomBlodget: Вам не нужно fixedили unsafeкод, вы также можете сделатьvar gch = GCHandle.Alloc("foo", GCHandleType.Pinned); var arr = new byte[sizeof(char) * ((string)gch.Target).Length]; Marshal.Copy(gch.AddrOfPinnedObject(), arr, 0, arr.Length); gch.Free();
user541686 28.01.2018 04:27:51

Чтобы преобразовать строку в byte [], используйте следующее решение:

string s = "abcdefghijklmnopqrstuvwxyz";
byte[] b = System.Text.UTF32Encoding.GetBytes(s);

Я надеюсь, что это помогает.

0
24.01.2019 12:02:39
это не решение проблемы!
Sebastian 12.04.2014 17:12:59
Почему ты так говоришь?
WonderWorker 13.04.2014 03:20:58
До вашего редактирования это было: s.Select(e => (byte)e)это работает только для символов ASCII. Но charтип предназначен для хранения единиц UTF16. Теперь после вашего редактирования код, по крайней мере, правильный, но он меняется от среды к среде, что делает его практически бесполезным. IMHO Encoding.Default следует использовать только для взаимодействия с устаревшим кодом Windows «Ansi codepage».
Sebastian 13.04.2014 08:04:29
Хорошая точка зрения. Как вы относитесь к byte [] b = new System.Text.UTF32Encoding (). GetBytes (s); ?
WonderWorker 14.04.2014 08:30:58
использовать byte[] b = System.Text.UTF32Encoding.GetBytes(s);, UTF8 одинаково хорошо.
Sebastian 14.04.2014 09:12:38

Строка может быть преобразована в байтовый массив несколькими различными способами, благодаря следующему факту: .NET поддерживает Unicode, а Unicode стандартизирует несколько разностных кодировок, называемых UTF. Они имеют различную длину представления байтов, но эквивалентны в том смысле, что когда строка кодируется, она может быть закодирована обратно в строку, но если строка закодирована с одним UTF и декодирована в предположении другого UTF, если ее можно прикрутить вверх.

Кроме того, .NET поддерживает не-Unicode-кодировки, но они недопустимы в общем случае (будет действительным, только если ограниченный поднабор кодовой точки Unicode используется в реальной строке, такой как ASCII). Внутри .NET поддерживает UTF-16, но для потокового представления обычно используется UTF-8. Это также стандарт де-факто для Интернета.

Неудивительно, что сериализация строки в массив байтов и десериализация поддерживаются классом System.Text.Encoding, который является абстрактным классом; его производные классы поддерживают конкретные кодировки: ASCIIEncodingи четыре UTF ( System.Text.UnicodeEncodingподдерживает UTF-16)

Ссылка на эту ссылку

Для сериализации в массив байтов используется System.Text.Encoding.GetBytes. Для обратной операции используйте System.Text.Encoding.GetChars. Эта функция возвращает массив символов, поэтому для получения строки используйте строковый конструктор System.String(char[]).
Ссылка на эту страницу.

Пример:

string myString = //... some string

System.Text.Encoding encoding = System.Text.Encoding.UTF8; //or some other, but prefer some UTF is Unicode is used
byte[] bytes = encoding.GetBytes(myString);

//next lines are written in response to a follow-up questions:

myString = new string(encoding.GetChars(bytes));
byte[] bytes = encoding.GetBytes(myString);
myString = new string(encoding.GetChars(bytes));
byte[] bytes = encoding.GetBytes(myString);

//how many times shall I repeat it to show there is a round-trip? :-)
2
17.08.2017 07:33:04

Символ является одновременно ключом поиска в таблице шрифтов и лексической традицией, такой как упорядочение, прописные и строчные буквы и т. Д.

Следовательно, символ не является байтом (8 бит), а байт не является символом. В частности, 256 перестановок байта не могут вместить тысячи символов в некоторых письменных языках, а тем более во всех языках. Следовательно, были разработаны различные способы кодирования символов. Некоторые кодируют для определенного класса языков (кодировка ASCII); несколько языков с использованием кодовых страниц (расширенный ASCII); или, амбициозно, все языки путем выборочного включения дополнительных байтов, если необходимо, Unicode.

Внутри системы, такой как .NET Framework, String подразумевает определенную кодировку символов. В .NET эта кодировка Unicode. Поскольку платформа читает и записывает Unicode по умолчанию, в .NET обычно не требуется кодировка символов.

Однако, как правило, для загрузки символьной строки в систему из потока байтов необходимо знать исходную кодировку, чтобы, следовательно, правильно интерпретировать и впоследствии ее перевести (в противном случае коды будут считаться уже находящимися в кодировке системы по умолчанию и, таким образом, визуализироваться). тарабарщина). Аналогично, когда строка записывается во внешний источник, она будет записана в определенной кодировке.

0
9.01.2017 01:21:19
Юникод не является кодировкой. Юникод - это абстрактное сопоставление символов с кодовыми точками. Есть несколько способов кодирования Unicode; в частности, UTF-8 и UTF-16 являются наиболее распространенными. .NET использует UTF-16, хотя я не уверен, что это UTF-16 LE или UTF-16 BE.
Kevin 26.08.2017 03:22:50
UTF-16 LE или UTF-16 BE не имеют значения: в строках используются неразрывные 16-битные кодовые единицы без какой-либо интерпретации. UTF-16BE или UTF-16 LE могут стать релевантными, только когда вы преобразуете строки в байтовые массивы или наоборот, потому что в то время вы будете указывать кодировку (и в этом случае строка должна сначала быть действительной UTF-16, но строки не должны быть действительными UTF-16). GetBytes () не обязательно возвращает действительный UTF-16 BE / LE, он использует простую арифметику; возвращаемый массив также не является допустимым UTF-8, но содержит произвольные байты. Порядок байтов в результате зависит от системы, если кодировка не указана.
verdy_p 7.09.2019 16:05:49
Это также означает, что string.UTF8.getBytes () может выдавать исключения кодирования из произвольных строк, содержимое которых не является допустимым UTF-16. В C # у вас есть выбор кодеров / декодеров (кодек) для использования. Вы можете использовать свой собственный кодек, который будет по-разному упаковывать / распаковывать байты, или может молча отбрасывать непарные суррогаты (если кодек пытается интерпретировать строку как UTF-16), или может отбрасывать старшие байты, или заменять / интерпретировать кодовые блоки недействителен в UTF-16 U + FFFD. Кодек также может использовать сжатие данных или шестнадцатеричное / base64 или экранирование ... Кодеки не ограничиваются только кодировкой UTF8.
verdy_p 7.09.2019 16:15:53
примечание: я использую здесь термин «кодек» добровольно, а не «кодирование», которое более конкретно и используется только для текста. Строки в C #, C, C ++, Java, Javascript / ECMAscript / ActiveScript НЕ ограничены только допустимым текстом: они представляют собой просто общую структуру хранения, удобную для текста и воспринимаемую библиотеками как текст (но не все). Таким образом, формы UTF вообще не применяются, кроме как внутри определенных API, использующих их (включая объекты кодирования UTF *). Да, вы можете хранить двоичную программу или изображение PNG в компактной неизменяемой строке вместо изменяемого массива, но вы можете
verdy_p 7.09.2019 18:50:54

Вы можете использовать следующий код для преобразования между строкой и байтовым массивом.

string s = "Hello World";

// String to Byte[]

byte[] byte1 = System.Text.Encoding.Default.GetBytes(s);

// OR

byte[] byte2 = System.Text.ASCIIEncoding.Default.GetBytes(s);

// Byte[] to string

string str = System.Text.Encoding.UTF8.GetString(byte1);
17
9.09.2014 11:30:51
VUP этот решил мою проблему (byte [] ff = ASCIIEncoding.ASCII.GetBytes (barcodetxt.Text);)
r.hamd 9.09.2015 13:19:57

Если вам действительно нужна копия нижележащих байтов строки, вы можете использовать функцию, подобную следующей. Тем не менее, вы не должны читать дальше, чтобы узнать, почему.

[DllImport(
        "msvcrt.dll",
        EntryPoint = "memcpy",
        CallingConvention = CallingConvention.Cdecl,
        SetLastError = false)]
private static extern unsafe void* UnsafeMemoryCopy(
    void* destination,
    void* source,
    uint count);

public static byte[] GetUnderlyingBytes(string source)
{
    var length = source.Length * sizeof(char);
    var result = new byte[length];
    unsafe
    {
        fixed (char* firstSourceChar = source)
        fixed (byte* firstDestination = result)
        {
            var firstSource = (byte*)firstSourceChar;
            UnsafeMemoryCopy(
                firstDestination,
                firstSource,
                (uint)length);
        }
    }

    return result;
}

Эта функция довольно быстро даст вам копию байтов, лежащих в основе вашей строки. Вы получите эти байты любым способом, который они кодируют в вашей системе. Эта кодировка почти наверняка является UTF-16LE, но это деталь реализации, о которой вам не нужно беспокоиться.

Было бы безопаснее, проще и надежнее просто позвонить,

System.Text.Encoding.Unicode.GetBytes()

По всей вероятности, это даст тот же результат, его легче набирать, а байты всегда будут возвращаться туда и обратно с вызовом

System.Text.Encoding.Unicode.GetString()
3
25.11.2014 10:29:12