str - c# 바이트 스트링 변환




인코딩을 수동으로 지정하지 않고 C#에서 문자열의 일관된 바이트 표현을 얻으려면 어떻게해야합니까? (20)

또한 인코딩을 고려해야하는 이유를 설명하십시오. 문자열에 저장된 바이트 수를 단순히 가져올 수 있습니까? 왜 인코딩에 대한 이러한 의존성이 있습니까?

왜냐하면 "문자열의 바이트"같은 것은 존재하지 않기 때문입니다.

문자열 (또는보다 일반적으로 텍스트)은 글자, 숫자 및 기타 기호로 구성된 문자입니다. 그게 다야. 그러나 컴퓨터는 문자에 대해 아무 것도 모른다. 바이트 만 처리 할 수 ​​있습니다. 따라서 컴퓨터를 사용하여 텍스트를 저장하거나 전송하려면 문자를 바이트로 변환해야합니다. 어떻게 그걸합니까? 여기 엔 인코딩이 등장합니다.

인코딩은 논리 문자를 실제 바이트로 변환하는 관례에 불과합니다. 가장 간단하고 잘 알려진 인코딩은 ASCII이며, 영어로 작성하는 경우 필요한 모든 것입니다. 다른 언어의 경우 가장 완벽한 인코딩이 필요하며 요즘 가장 안전한 선택 인 유니 코드입니다.

요컨대, "인코딩을 사용하지 않고 문자열의 바이트를 얻으려고"하는 것은 "언어를 사용하지 않고 텍스트를 작성하는 것"만큼이나 어렵습니다.

그건 그렇고, 나는이 문제를 조금이라도 읽는 것이 좋습니다 joelonsoftware.com/articles/Unicode.html

특정 인코딩을 수동으로 지정하지 않고 .NET (C #)에서 stringbyte[] 로 변환하려면 어떻게해야합니까?

문자열을 암호화 할 것입니다. 변환하지 않고도 암호화 할 수 있지만 인코딩이 왜 여기에서 재생되는지 알고 싶습니다.

또한 인코딩을 고려해야하는 이유는 무엇입니까? 문자열에 저장된 바이트 수를 단순히 가져올 수 있습니까? 문자 인코딩에 의존하는 이유는 무엇입니까?


특정 인코딩을 수동으로 지정하지 않고 .NET (C #)에서 문자열을 byte []로 변환하려면 어떻게해야합니까?

.NET 의 string 은 텍스트를 UTF-16 코드 단위의 시퀀스로 나타내므로 바이트는 이미 UTF-16로 메모리에 인코딩됩니다.

메흐 다드의 대답

Mehrdad의 답변을 사용할 수는 있지만 문자는 UTF-16이므로 실제로 인코딩을 사용합니다. 그것은 ToCharArray를 호출 하여 소스 를보고 a를 만들고 char[]이를 메모리에 직접 복사합니다. 그런 다음 할당 된 바이트 배열에 데이터를 복사합니다. 후드에서 기본 바이트를 두 번 복사 하고 호출 후에 사용되지 않는 char 배열을 할당합니다.

Tom Blodget의 답변

Tom Blodget의 답변 은 Mehrdad보다 20-30 % 빠릅니다. char 배열을 할당하고 바이트를 복사하는 중간 단계를 건너 뛸 수 있기 때문에 /unsafe옵션 을 사용하여 컴파일해야합니다 . 절대 인코딩을 사용하고 싶지 않다면, 이것이 최선의 방법이라고 생각합니다. 암호화 로그인을 fixed블록 안에 넣으면 별도의 바이트 배열을 할당하고 바이트를 복사 할 필요조차 없습니다.

또한 인코딩을 고려해야하는 이유는 무엇입니까? 문자열에 저장된 바이트 수를 단순히 가져올 수 있습니까? 문자 인코딩에 의존하는 이유는 무엇입니까?

그것이 올바른 방법이기 때문에. string추상화입니다.

잘못된 문자로 '문자열'이 있으면 인코딩을 사용하면 문제가 발생할 수 있지만 그렇게해서는 안됩니다. 잘못된 문자로 문자열에 데이터를 가져 오는 경우 잘못 처리하는 것입니다. 바이트 배열 또는 Base64 인코딩을 사용하여 시작해야합니다.

사용 System.Text.Encoding.Unicode하면 코드가 더 탄력적입니다. 코드가 실행될 시스템 의 endianness 에 대해 걱정할 필요가 없습니다 . CLR의 다음 버전에서 다른 내부 문자 인코딩을 사용하더라도 걱정할 필요가 없습니다.

문제는 인코딩에 대해 걱정할 필요가없는 이유가 아니라 왜 이것을 무시하고 다른 것을 사용하고 싶은지입니다. 인코딩은 일련의 바이트로 된 문자열의 추상화를 나타 내기위한 것입니다. System.Text.Encoding.Unicode리틀 엔디 언 바이트 순서 인코딩을 제공하고 현재와 미래의 모든 시스템에서 동일하게 수행합니다.


여기에 대한 대답과는 달리 바이트를 해석 할 필요가 없다면 인코딩에 대해 걱정할 필요가 없습니다!

당신이 언급 한 것처럼, 당신의 목표는 단순히 "문자열이 저장된 바이트를 얻는 것" 입니다.
물론 바이트에서 문자열을 다시 구성 할 수 있어야합니다.

이러한 목표를 달성하기 위해 사람들이 왜 계속 인코딩을 필요로하는지에 대해 이해하지 못합니다 . 확실히 인코딩을 걱정할 필요는 없습니다.

대신 다음을 수행하십시오.

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);
}

프로그램 (또는 다른 프로그램)이 바이트를 어떻게 든 해석 하려고하지 않는 한, 분명히 말하려고하지 않았지만,이 접근법에는 아무런 문제가 없습니다 ! 인코딩에 대해 걱정하면 실제 이유없이 더 복잡한 삶을 살게됩니다.

이 접근법의 추가 이점 :

문자열에 유효하지 않은 문자가 포함되어 있더라도 상관 없습니다. 왜냐하면 여전히 데이터를 가져 와서 어쨌든 원래의 문자열을 재구성 할 수 있기 때문입니다!

바이트를보고 있기 때문에 인코딩되고 디코딩 됩니다 .

특정 인코딩을 사용했다면 잘못된 문자 인코딩 / 디코딩 문제가 발생할 수 있습니다.


1 문자는 1 바이트 이상 (약 6까지)으로 표현할 수 있고 다른 인코딩은 이러한 바이트를 다르게 처리하므로 인코딩을 고려해야합니다.

Joel은 이것에 대한 글을 올렸습니다 :

joelonsoftware.com/articles/Unicode.html


Mehrdrad의 소리 share 효과가 있음을 증명하기 위해, 그의 접근법은 대다수가 내 대답에 대해 평준화 한 대립 [BinaryFormatter (심지어는 모두 System.Text.Encoding.UTF8.GetBytes , System.Text.Encoding.Unicode.GetBytes 유죄로 유지할 수도 있습니다 System.Text.Encoding.Unicode.GetBytes : 이러한 인코딩 메소드는 예를 들어 상위 대리 문자 System.Text.Encoding.Unicode.GetBytes 유지할 수 없으며 단지 상위 대리 문자를 값 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 또는 제 3 자 구성 요소를 사용하여 문자열을 유지할 수 있습니다. 직렬화되지 않은 대리 문자가 포함되어 있어도 문자열을 유지할 수 있습니다. 나는이 모든 것을 google에 다음 : serialization unpaired 대리 문자를 . NET을 . 이것은 내가 잠을 자게하지는 못하지만, 때때로 모든 사람들이 내 대답에 대해 논평하는 것이 괴롭다. 문제가 있다고 대답하는 사람이 있지만 아직 쌍을 이루지 않은 대리 문자에 대해서는 똑같은 결함이있다.

Darn, Microsoft는 System.Buffer.BlockCopyBinaryFormatterツ에서 사용 했어야합니다.

谢谢!


귀하의 질문 (바이트를 얻는 방법)의 첫 번째 부분은 이미 다른 사람들이 대답했습니다. System.Text.Encoding 네임 스페이스를 살펴보십시오.

나는 당신의 후속 질문을 말할 것입니다 : 왜 당신은 인코딩을 선택해야합니까? 왜 당신은 문자열 클래스 자체에서 그것을 얻을 수 없습니까?

대답은 두 부분으로 나뉩니다.

우선, 문자열 클래스에 의해 내부적으로 사용되는 바이트 는 중요하지 않으며 , 당신이 가정 할 때마다 버그를 일으킬 가능성이 높습니다.

귀하의 프로그램이 전적으로 .Net 세계에 있다면, 네트워크를 통해 데이터를 전송하더라도 문자열에 대한 바이트 배열을 전혀 염려 할 필요가 없습니다. 대신 .Net Serialization을 사용하여 데이터 전송에 대해 걱정하십시오. 실제 바이트에 대해서는 더 이상 걱정하지 않아도됩니다. 직렬화 포맷터가이를 처리합니다.

반면에, .Net 직렬화 된 스트림에서 데이터를 가져올 수 없다는 어딘가에서이 바이트를 보내는 경우 어떻게해야할까요? 이 경우에는 인코딩에 대해 걱정할 필요가 있습니다. 분명히 외부 시스템이 신경을 써야하기 때문입니다. 다시 말하지만 문자열에 사용 된 내부 바이트는 중요하지 않습니다. 인코딩을 선택해야 수신자 측에서이 인코딩에 대해 명시 할 수 있습니다. 내부적으로 .Net에서 사용되는 인코딩과 동일하더라도 마찬가지입니다.

이 경우 바이트 변수를 생성하는 작업을 줄일 수 있다는 생각과 함께 가능하면 메모리에서 문자열 변수에 의해 저장된 실제 바이트를 사용하는 것을 선호 할 수도 있습니다. 그러나 필자는 출력을 다른 쪽에서 이해하고 인코딩에 명시 해야 함을 보장하는 것보다 중요하지 않다. 또한 내부 바이트를 실제로 일치시키려는 경우 이미 Unicode 인코딩을 선택하여 성능을 향상시킬 수 있습니다.

두 번째 부분으로 이동합니다. Unicode 인코딩을 선택하면 .NET에서 기본 바이트를 사용합니다. 새로운 인코딩 된 Unicode-Plus가 나오면 .Net 런타임은 프로그램을 손상시키지 않고 더 새롭고 향상된 인코딩 모델을 자유롭게 사용해야하기 때문에이 인코딩을 선택해야합니다. 그러나, 잠시 동안 (그리고 예측 가능한 미래) 유니 코드 인코딩을 선택하면 원하는 것을 얻을 수 있습니다.

문자열이 다시 쓰여 져야한다는 것을 이해하는 것도 중요합니다. 일치하는 인코딩을 사용하는 경우에도 최소한 비트 패턴의 일부 번역이 필요합니다. 컴퓨터는 Big vs Little Endian, 네트워크 바이트 순서, 패킷 화, 세션 정보 등을 설명해야합니다.


대답은 매우 복잡합니다. 다음을 위해 포함 된 .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);

할 필요가 없다면 바퀴를 재발 명하지 마십시오 ...


두 가지 방법:

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;
}

나는 맨 위보다 맨 아래를 자주 사용하는 경향이 있으며, 속도를 위해 벤치마킹하지 않았습니다.


용도:

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

결과는 다음과 같습니다.

[0] = 115
[1] = 116
[2] = 114
[3] = 105
[4] = 110
[5] = 103

이것은 대중적인 질문입니다. 저자가 묻는 질문을 이해하는 것이 중요하며 가장 공통적 인 필요성과 다를 수 있습니다. 필요하지 않은 코드의 오용을 방지하기 위해 나중에 대답했습니다.

공통적 인 필요

모든 문자열에는 문자 집합과 인코딩이 있습니다. 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 경우 원본 문자 집합은 유니 코드입니다.

유일한 혼란스러운 점은 .NET에서 해당 문자 집합의 특정 인코딩 이름에 대한 문자 집합 이름을 사용한다는 것입니다. Encoding.UnicodeEncoding.Unicode 이라고해야합니다.

그것은 대부분의 용도에 해당합니다. 그것이 당신이 필요로하는 것이라면 여기에서 읽지 마라. 인코딩이 무엇인지 이해하지 못한다면 joelonsoftware.com/articles/Unicode.html 의 재미있는 joelonsoftware.com/articles/Unicode.html 를보십시오.

특별한 필요

이제 저자는 "모든 문자열은 바이트 배열로 저장됩니다. 맞습니까? 단순히 그 바이트를 가질 수없는 이유는 무엇입니까?"

그는 개종을 원하지 않습니다.

C # 스펙에서 :

C #의 문자 및 문자열 처리는 유니 코드 인코딩을 사용합니다. char 유형은 UTF-16 코드 단위를 나타내며 string 유형은 UTF-16 코드 단위의시 v 스를 나타냄니다.

따라서 우리는 널 변환 (예 : UTF-16에서 UTF-16으로 변환)을 요청하면 원하는 결과를 얻을 수 있음을 알고 있습니다.

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

그러나 인코딩에 대한 언급을 피하려면 다른 방식으로해야합니다. 중간 데이터 형식을 사용할 수있는 경우 개념적 바로 가기가 있습니다.

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

Mehrdad의 대답 은 BlockCopy 사용 BlockCopy Char 배열을 Byte 배열로 변환하는 방법을 보여줍니다. 그러나이 문자열을 두 번 복사합니다! 또한 인코딩 전용 코드 인 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가 지적했듯이 그 결과는 컴퓨터의 엔디안 (endianness)에 달려 있습니다. 그러나 질문 저자는 그것에 관심이 없다.


LINQ를 사용한 간단한 코드

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

편집 : 아래에 주석으로, 그것은 좋은 방법이 아닙니다.

보다 적절한 코딩을 사용하여 LINQ를 이해하는 데 계속 사용할 수 있습니다.

string s = "abc"
byte[] b = s.Cast<byte>().ToArray();

가장 빠른 방법

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

편집 Makotosan 지금이 최선의 방법이라고 :

Encoding.UTF8.GetBytes(text)

문자열과 바이트 배열 간의 변환을 위해 다음 코드를 사용할 수 있습니다.

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);

Span<T>C # 7.2 가 출시되면서 문자열의 기본 메모리 표현을 관리되는 바이트 배열로 캡처하는 표준 기술은 다음과 같습니다.

byte[] bytes = "rubbish_\u9999_string".AsSpan().AsBytes().ToArray();

다시 변환하는 것은 비 스타터 (non-starter) 여야합니다. 왜냐하면 실제로 데이터를 어떻게 든 해석하지만 실제로는 완전한 의미로 해석하기 때문입니다.

string s;
unsafe
{
    fixed (char* f = &bytes.AsSpan().NonPortableCast<byte, char>().DangerousGetPinnableReference())
    {
        s = new string(f);
    }
}

이름들 NonPortableCastDangerousGetPinnableReference당신이 아마도 이것을하지 않아야한다는 주장을 더해야합니다.

참고로 작업 Span<T>하려면 System.Memory NuGet 패키지를 설치해야 합니다 .

그럼에도 불구하고 실제 원래의 질문과 후속 의견은 기본 메모리가 "해석 된"것이 아니라는 것을 의미합니다 (나는 이것을 의미하는 것으로 수정되거나 읽혀지지 않는다고 가정합니다). 이것은 Stream클래스의 일부 구현 문자열에 대한 데이터에 대해 추론하는 대신에 사용해야합니다.


다음 코드를 사용 string하여 a byte array를 .NET 으로 변환 할 수 있습니다 .

string s_unicode = "abcéabc";
byte[] utf8Bytes = System.Text.Encoding.UTF8.GetBytes(s_unicode);

문자열의 기본 바이트를 실제로 복사하려면 다음과 같은 함수를 사용할 수 있습니다. 그러나 이유를 알아 내기 위해 계속해서 읽지 마십시오 .

[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()

이 문자열은 다음과 같은 사실 때문에 몇 가지 다른 방법으로 바이트 배열로 변환 될 수 있습니다. .NET은 유니 코드를 지원하고 유니 코드는 UTF라고하는 여러 차이 인코딩을 표준화합니다. 그들은 다른 길이의 바이트 표현을 가지고 있지만 문자열이 인코딩 될 때 문자열로 다시 코딩 될 수 있다는 의미에서 동등합니다. 그러나 문자열이 하나의 UTF로 인코딩되고 다른 UTF의 가정에서 디코딩 될 수 있다면 스크램블 될 수 있습니다 쪽으로.

또한 .NET은 비 유니 코드 인코딩을 지원하지만 일반적인 경우에는 유효하지 않습니다 (유니 코드 코드 포인트의 제한된 하위 집합이 ASCII와 같은 실제 문자열에서 사용되는 경우에만 유효합니다). 내부적으로 .NET은 UTF-16을 지원하지만 스트림 표현에서는 일반적으로 UTF-8이 사용됩니다. 또한 인터넷 표준이기도합니다.

놀랍지 않게 문자열을 byte 배열과 deserialization 배열로 직렬화 System.Text.Encoding하는 것은 추상 클래스 인 클래스 에서 지원됩니다 . 파생 클래스는 구체적인 인코딩을 지원합니다 : ASCIIEncoding4 개의 System.Text.UnicodeEncodingUTF ( 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? :-)

중요한 문제는 문자열의 글리프가 32 비트 (문자 코드의 경우 16 비트)를 차지하지만 바이트는 8 비트 만 남겨두기 때문입니다. ASCII 문자 만 포함하는 문자열로 자신을 제한하지 않으면 일대일 매핑이 존재하지 않습니다. System.Text.Encoding에는 문자열을 byte []에 매핑하는 많은 방법이 있습니다. 정보 손실을 방지하고 바이트 []를 문자열로 다시 매핑해야 할 때 클라이언트에서 사용하기 쉬운 메서드를 선택해야합니다. .

Utf8은 인기있는 인코딩으로 압축되지 않고 손실이 없습니다.


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());

byte[] strToByteArray(string str)
{
    System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
    return enc.GetBytes(str);
}




character-encoding