Nasıl dönüştürebilirim stringa byte[]el ile belirli kodlama belirtmeden .NET (C #) içinde?

Dizeyi şifreleyeceğim. Dönüştürmeden şifreleyebilirim, ama yine de kodlamanın neden burada oynamaya geldiğini bilmek istiyorum.

Ayrıca, kodlama neden dikkate alınmalıdır? Dize içinde saklanan baytları alamıyor muyum? Neden karakter kodlamalarına bağımlılık var?

Burada cevapları aksine, kodlama hakkında endişe gerek YAPMAYIN eğer bayt yorumlanabilir gerek yok!

Bahsettiğiniz gibi, amacınız basitçe "dizginin içinde saklandığı baytları almak" tır .
(Ve elbette, dizeyi baytlardan yeniden oluşturabilmek için.)

Bu hedefler için dürüst do not insanlar kodlamaları gerektiğini belirten tutmak anlamak. Bunun için kodlamalar konusunda endişelenmenize gerek yoktur.

Bunun yerine bunu yapın:

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

Programınız (veya diğer programlarınız) bir şekilde baytları yorumlamaya çalışmadığı sürece, bunu yapmak istediğinizden bahsetmediğiniz açıktır, o zaman bu yaklaşımda yanlış bir şey yoktur ! Kodlamalardan endişe etmek, gerçek bir sebep olmadan hayatınızı daha karmaşık hale getirir.

Bu yaklaşıma ek fayda:

Dizenin geçersiz karakterler içerip içermemesi önemli değildir, çünkü yine de verileri alıp orijinal dizgiyi yeniden yapılandırabilirsiniz!

Aynı şekilde kodlanacak ve deşifre edilecektir, çünkü sadece baytlara bakıyorsunuz .

Bununla birlikte, belirli bir kodlama kullandıysanız, geçersiz karakterleri kodlama / kod çözme konusunda sorun yaşarsınız.

Dizenizin kodlamasına bağlıdır ( ASCII , UTF-8 , ...).

Örneğin:

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

Kodlamanın neden önemli olduğuna dair küçük bir örnek:

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 sadece özel karakterlerle başa çıkmak için donanımlı değildir.

Dahili olarak .NET çerçevesi, dizeleri temsil etmek için UTF-16 kullanır , bu nedenle .NET'in kullandığı tam baytları almak istiyorsanız kullanın System.Text.Encoding.Unicode.GetBytes (...).

Daha fazla bilgi için bkz. .NET Framework'teki (MSDN) Karakter Kodlaması .

Kabul edilen cevap çok ama çok karmaşık. Bunun için dahil edilen .NET sınıflarını kullanın:

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

Gerekmiyorsa tekerleği yeniden icat etmeyin ...

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

Kodlamayı dikkate almanız gerekir, çünkü 1 karakter 1 veya daha fazla bayt (yaklaşık 6'ya kadar) ile temsil edilebilir ve farklı kodlamalar bu baytlara farklı şekilde davranır.

Joel'in bu konuda bir yazısı var:

Mutlak Minimum Her Yazılım Geliştiricisi Kesinlikle, Olumlu Unicode ve Karakter Kümeleri Hakkında Bilmeli (Bahane Yok!)

Bu popüler bir soru. Yazarın ne sorduğunu ve bunun en yaygın ihtiyaç olandan farklı olduğunu anlamak önemlidir. Kodun gerekli olmadığı yerlerde kötüye kullanılmasını engellemek için, daha sonra önce cevap verdim.

Ortak İhtiyaç

Her dizenin bir karakter kümesi ve kodlaması vardır. Bir System.Stringnesneyi bir diziye dönüştürdüğünüzde System.Bytehala bir karakter kümesi ve kodlaması vardır. Çoğu kullanım için, hangi karakter kümesine ve kodlamaya ihtiyacınız olduğunu bilirsiniz ve .NET "dönüşümle kopyalama" yı kolaylaştırır. Sadece uygun Encodingsınıfı seçin .

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

Dönüşümün, hedef karakter kümesinin veya kodlamanın kaynaktaki bir karakteri desteklemediği durumları ele alması gerekebilir. Bazı seçenekleriniz var: istisna, değiştirme veya atlama. Varsayılan ilke '?' Yerine kullanılır.

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

Açıkçası, dönüşümler mutlaka kayıpsız değildir!

Not: System.StringKaynak karakter kümesi Unicode'dur.

Kafa karıştırıcı olan tek şey, .NET'in o karakter kümesinin belirli bir kodlamasının adı için bir karakter kümesinin adını kullanmasıdır. Encoding.Unicodeçağrılmalıdır Encoding.UTF16.

Çoğu kullanım için bu kadar. Eğer ihtiyacınız olan buysa, burada okumayı bırakın. Bir kodlamanın ne olduğunu anlamadıysanız eğlenceli Joel Spolsky makalesine bakın .

Özel İhtiyaç

Şimdi, soru yazar, "Her dize bir bayt dizisi olarak saklanır, değil mi? Neden bu baytlara sahip olamıyorum?"

Herhangi bir dönüşüm istemiyor.

Gönderen C # spec :

C # 'da karakter ve dize işleme Unicode kodlaması kullanır. Karakter türü bir UTF-16 kod birimini ve dize türü bir dizi UTF-16 kod birimini temsil eder.

Dolayısıyla, boş dönüşüm (yani UTF-16'dan UTF-16'ya) istersek, istenen sonucu alacağımızı biliyoruz:

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

Ancak kodlamalardan bahsetmemek için, bunu başka bir şekilde yapmalıyız. Bir ara veri türü kabul edilebilirse, bunun için kavramsal bir kısayol vardır:

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

Bu bize istenen veri tipini vermez, ancak Mehrdad'ın cevabı , bu Char dizisinin BlockCopy kullanarak bir Byte dizisine nasıl dönüştürüleceğini gösterir . Ancak, bu dizeyi iki kez kopyalar! Ve çok açık bir şekilde kodlamaya özgü kod kullanır: veri türü System.Char.

Dize'nin saklandığı gerçek baytlara ulaşmanın tek yolu bir işaretçi kullanmaktır. fixedİfadesi değerlerinin adresini alarak verir. C # spec'ten:

String türünde bir ifade için [...] başlatıcı, dizgideki ilk karakterin adresini hesaplar.

Bunu yapmak için, derleyici kod atlama ile dize nesnesinin diğer bölümleri üzerine yazar RuntimeHelpers.OffsetToStringData. Ham baytları almak için dizeye bir işaretçi oluşturun ve gereken bayt sayısını kopyalayın.

// 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'un işaret ettiği gibi, sonuç makinenin endianitesine bağlıdır. Ancak soru yazarı bununla ilgilenmiyor.

Sorunuzun ilk kısmı (baytların nasıl elde edileceği) başkaları tarafından zaten cevaplandı: System.Text.Encodingad alanına bakın.

Takip eden sorunuza değineceğim: neden bir kodlama seçmeniz gerekiyor? Bunu neden string sınıfının kendisinden alamıyorsunuz?

Cevap iki bölümden oluşmaktadır.

Her şeyden önce, string sınıfı tarafından dahili olarak kullanılan baytlar önemli değildir ve ne zaman yaparsanız yapın muhtemelen bir hata getiriyorsunuzdur.

Programınız tamamen .Net dünyasındaysa, bir ağ üzerinden veri gönderiyor olsanız bile, dizeler için bayt dizileri alma konusunda endişelenmenize gerek yoktur. Bunun yerine, verileri iletme konusunda endişelenmek için .Net Serialization kullanın. Artık gerçek baytlar için endişelenmenize gerek yok: Serileştirme formatlayıcı bunu sizin için yapar.

Öte yandan, bu baytları bir .Net serileştirilmiş akışından veri çekeceğini garanti edemeyeceğiniz bir yere gönderiyorsanız? Bu durumda kesinlikle kodlama konusunda endişelenmeniz gerekir, çünkü bu harici sistem umurundadır. Bu nedenle, dize tarafından kullanılan dahili baytlar önemli değildir: bir kodlama seçmeniz gerekir, böylece .Net tarafından dahili olarak kullanılan kodlama ile aynı olsa bile, alıcı uçtaki bu kodlama hakkında açık olursunuz.

Bu durumda, bellekte dize değişkeni tarafından saklanan gerçek baytları mümkünse, bayt akışınızı oluşturmak için biraz çalışma kaydedebileceği fikri ile kullanmayı tercih edebileceğinizi anlıyorum. Ancak, bu emin çıkış diğer ucunda anlaşılmaktadır hale kıyasla sadece önemli değil, ve o garantiye size koymak gerekir kodlamayla ilgili açık ve net olması. Ayrıca, dahili baytlarınızla gerçekten eşleşmek istiyorsanız, zaten Unicodekodlamayı seçebilir ve bu performans tasarruflarını elde edebilirsiniz.

Hangi toplama ... İkinci bölümde getiriyor Unicodekodlamayı edilir yatan byte kullanarak .NET anlatan. Bu kodlamayı seçmeniz gerekiyor, çünkü bazı yeni fangled Unicode-Plus ortaya çıktığında .Net çalışma zamanının bu yeni, daha iyi kodlama modelini programınızı bozmadan kullanmak için ücretsiz olması gerekir. Ancak, şimdilik (ve öngörülebilir bir gelecek için), sadece Unicode kodlamasını seçmek size ne istediğinizi verir.

Dizenizin kabloya yeniden yazılması gerektiğini anlamak da önemlidir ve bu, eşleşen bir kodlama kullansanız bile bit deseninin en azından bazı çevirilerini içerir . Bilgisayarın Big vs Little Endian, ağ bayt sırası, paketleme, oturum bilgileri vb.

Sadece Mehrdrad ses göstermek için cevap eserler, onun yaklaşımı bile devam edebilir eşleşmemiş yedek karakterlerini birçok cevabım hakkında öne sürdüğü olan (fakat bunlardan herkes örneğin aynı derecede suçludur System.Text.Encoding.UTF8.GetBytes, System.Text.Encoding.Unicode.GetBytes; bu kodlama yöntemleri yüksek suret devam edemez karakterler d800, örneğin ve bu sadece sadece değerle yüksek vekil karakterleri değiştirmek 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);
    }        
}

Çıktı:

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

Bunu System.Text.Encoding.UTF8.GetBytes veya System.Text.Encoding.Unicode.GetBytes ile deneyin , yalnızca yüksek vekil karakterleri fffd değeriyle değiştirecekler

Bu soruda her hareket olduğunda, hala eşleşmemiş vekil karakterleri içeriyor olsa bile dizeleri devam ettirebilecek bir serileştirici (Microsoft veya 3. taraf bileşeninden olsun) düşünüyorum; Ben her zaman bu google: serileştirme eşleşmemiş vekil karakter. NET . Bu beni hiç uykuyu kaybettirmiyor, ama şimdi ve sonra cevabımın kusurlu olduğuna dair yorum yapan birileri rahatsız edici, ama eşleşmemiş vekil karakterler söz konusu olduğunda cevapları eşit derecede kusurlu.

Lanet, Microsoft sadece kullanılmış olmalıdır System.Buffer.BlockCopyonun içinde BinaryFormatterツ

谢谢!

Bunu deneyin, çok daha az kod:

System.Text.Encoding.UTF8.GetBytes("TEST String");

Tüm cevapları okudum ve eşleşmemiş vekilleri düşüren kodlama ya da serileştirme hakkındaydılar.

Örneğin, dize, örneğin bir parola karması depolayan bir bayt dizisi kullanılarak oluşturulduğu SQL Server'dan geldiğinde kötüdür . Ondan bir şey çıkarırsak, geçersiz bir karmayı depolar ve XML'de saklamak istiyorsak, bozulmadan bırakmak isteriz (çünkü XML yazarı bulduğu eşleştirilmemiş herhangi bir vekil için bir istisna bırakır).

Bu tür durumlarda bayt dizilerinin Base64 kodlamasını kullanıyorum , ama hey, internette C # 'da bunun tek bir çözümü var ve hata var ve sadece bir yol var, bu yüzden hatayı düzelttim ve geri yazdım prosedür. İşte gelecekteki Google çalışanları:

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

Ayrıca kodlamanın neden dikkate alınması gerektiğini de açıklayınız. Dize içinde saklanan baytları alamıyor muyum? Neden bu kodlamaya bağımlılık? !!!

Çünkü "dizenin baytı" diye bir şey yoktur.

Bir dize (veya daha genel olarak bir metin) karakterlerden oluşur: harfler, rakamlar ve diğer simgeler. Bu kadar. Ancak bilgisayarlar karakterler hakkında hiçbir şey bilmiyorlar; sadece baytlarla başa çıkabilirler. Bu nedenle, bir bilgisayar kullanarak metin depolamak veya iletmek istiyorsanız, karakterleri bayta dönüştürmeniz gerekir. Bunu nasıl yaptın? Kodlamalar burada devreye giriyor.

Kodlama, mantıksal karakterleri fiziksel baytlara çevirmek için kullanılan bir kuraldan başka bir şey değildir. En basit ve en iyi bilinen kodlama ASCII'dir ve İngilizce yazmanız gereken tek şey budur. Diğer diller için, daha eksiksiz kodlamalara ihtiyacınız olacak, Unicode lezzetlerinden herhangi biri bugünlerde en güvenli seçim.

Kısacası, "kodlama kullanmadan bir dizenin baytını almaya" çalışmak, "herhangi bir dil kullanmadan metin yazmak" kadar imkansızdır.

Bu arada, size (ve bu konudaki herhangi birine) bu küçük bilgeliği okumanızı şiddetle tavsiye ederim: Mutlak Minimum Her Yazılım Geliştiricisi Kesinlikle, Olumlu Unicode ve Karakter Setleri Hakkında Bilmelisiniz (Mazeret Yok!)

C # stringbir bytedizi dönüştürmek için :

public static byte[] StrToByteArray(string str)
{
   System.Text.UTF8Encoding  encoding=new System.Text.UTF8Encoding();
   return encoding.GetBytes(str);
}

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

Dize ve bayt dizisi arasında dönüştürme için aşağıdaki kodu kullanabilirsiniz.

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

Gelişiyle birlikte Span<T>C # 7.2 ile piyasaya, kurallı bir tekniktir yönetilen bir bayt dizisi bir dize yatan hafıza temsilini yakalamak için:

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

Geri dönüştürmek başlatıcı olmamalıdır, çünkü bu aslında verileri bir şekilde yorumladığınız anlamına gelir, ancak tamlık uğruna:

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

İsimler NonPortableCastve DangerousGetPinnableReferencemuhtemelen bunu yapmamanız gerektiği argümanı olmalıdır.

İleSpan<T> çalışmanın System.Memory NuGet paketinin yüklenmesini gerektirdiğini unutmayın .

Ne olursa olsun, gerçek orijinal soru ve takip eden yorumlar yatan bellek gösteren (ı değiştirilmiş ya da olduğu gibi-yazmaya gerek ötesine değil okuma aracı varsayalım) "yorumlanır" varlık değildir ima Bunun bazı uygulama Streamsınıfının veri hakkında akıl yürütme yerine dize olarak kullanılmalıdır.

Emin değilim, ama dize bayt ile verimsiz Chars bir dizi olarak bilgi depolar düşünüyorum. Özellikle, bir Char'ın tanımı "Unicode karakteri temsil eder" dir.

bu örnek örneği al:

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 cevabının her iki durumda da 14 bayt, UTF-8 cevabının birincisi için sadece 9 bayt ve ikincisi için sadece 7 bayt olduğunu unutmayın.

Bu nedenle, yalnızca dize tarafından kullanılan baytları istiyorsanız, sadece kullanın Encoding.Unicode, ancak depolama alanı ile verimsiz olacaktır.

Temel sorun, bir dizedeki glifin 32 bit (bir karakter kodu için 16 bit) alması, ancak bir baytın sadece 8 bit içermesidir. Kendinizi yalnızca ASCII karakterleri içeren dizelerle sınırlamadığınız sürece bire bir eşleme mevcut değildir. System.Text.Encoding öğesinin bir dizeyi bayt [] ile eşleştirmek için birçok yolu vardır, bilgi kaybını önleyen ve bayt [] öğesini bir dizeyle eşlemesi gerektiğinde müşteriniz tarafından kullanımı kolay olanı seçmeniz gerekir. .

Utf8 popüler bir kodlamadır, kompakt ve kayıplı değildir.

kullanın:

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

Sonuç:

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

En hızlı yol

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

Makotosan yorum olarak EDIT şimdi bu en iyi yolu olduğunu:

Encoding.UTF8.GetBytes(text)

Belirli bir kodlamayı el ile belirtmeden .NET (C #) içindeki bir dizeyi [] baytına nasıl dönüştürebilirim?

Bir dize , metni UTF-16 kod birimlerinin dizisi olarak temsil eder, bu nedenle baytlar zaten UTF-16'daki bellekte kodlanır.

Mehrdad'ın Cevabı

Mehrdad'ın cevabını kullanabilirsiniz , ancak karakter UTF-16 olduğu için aslında bir kodlama kullanır. Bu bakarak ToCharArray çağıran kaynağı bir oluşturur char[]doğrudan kendisine ve kopya bellek. Ardından, verileri ayrılan bir bayt dizisine kopyalar. Kaputun altında, alttaki baytları iki kez kopyalar ve çağrıdan sonra kullanılmayan bir char dizisi tahsis eder.

Tom Blodget kullanıcısının Yanıtı

Tom Blodget'ın cevabı , Mehrdad'dan % 20-30 daha hızlıdır, çünkü bir char dizisi tahsis etme ve baytları ona kopyalama ara adımını atlar, ancak bu /unsafeseçeneği derlemenizi gerektirir . Eğer kesinlikle kodlamayı kullanmak istemiyorsanız, bence bu yol. Şifreleme girişinizi fixedbloğun içine koyarsanız, ayrı bir bayt dizisi tahsis etmeniz ve baytları dizine kopyalamanız bile gerekmez.

Ayrıca, kodlama neden dikkate alınmalıdır? Dize içinde saklanan baytları alamıyor muyum? Neden karakter kodlamalarına bağımlılık var?

Çünkü bunu yapmanın doğru yolu budur. stringbir soyutlamadır.

Geçersiz karakterlerle 'dizeleriniz' varsa, kodlama kullanmak size sorun çıkarabilir, ancak bu olmamalıdır. Dizenize geçersiz karakterlerle veri alıyorsanız, bunu yanlış yapıyorsunuz demektir. Başlamak için muhtemelen bir bayt dizisi veya Base64 kodlaması kullanıyor olmanız gerekir.

Kullanırsanız System.Text.Encoding.Unicode, kodunuz daha esnek olacaktır. Kodunuzun çalışacağı sistemin endianitesi hakkında endişelenmenize gerek yoktur . CLR'nin sonraki sürümünde farklı bir dahili karakter kodlaması kullanılacaksa endişelenmenize gerek yoktur.

Sorunun neden kodlama konusunda endişelenmek istediğiniz değil, neden onu görmezden gelip başka bir şey kullanmak istediğinizi düşündüğünü düşünüyorum. Kodlama, bir dizinin bayt dizisindeki soyutlamasını temsil eder. System.Text.Encoding.Unicodesize küçük bir endian bayt sırası kodlaması verecek ve her sistemde şimdi ve gelecekte de aynı işlemi gerçekleştirecektir.

OP'nin sorusuna en yakın yaklaşım, aslında nesneye giren ve baytları çıkaran Tom Blodget's. String Object uygulamasına bağlı olduğu için en yakın diyorum.

"Can't I simply get what bytes the string has been stored in?"

Tabii, ama sorudaki temel hata burada ortaya çıkıyor. Dize, ilginç bir veri yapısına sahip olabilecek bir nesnedir. Bunu zaten biliyoruz, çünkü eşleştirilmemiş vekillerin saklanmasına izin veriyor. Uzunluğu depolayabilir. Hızlı saymaya izin veren 'eşleştirilmiş' her bir vekilin işaretçisi olabilir. Vb Bu ekstra baytların tümü karakter verilerinin bir parçası değildir.

İstediğiniz bir dizideki her karakterin bayt değeridir. İşte bu noktada 'kodlama' devreye giriyor. Varsayılan olarak UTF-16LE alacaksınız. Eğer gidiş-dönüş dışında baytların kendileri umursamıyorsanız, 'varsayılan' dahil herhangi bir kodlamayı seçebilir ve daha sonra geri dönüştürebilirsiniz (varsayılan kodlamanın ne olduğu, kod noktaları, hata düzeltmeleri gibi aynı parametreleri varsayarak) , eşleştirilmemiş vekiller gibi izin verilen şeyler.

Ama neden 'kodlamayı' büyüye bırakalım? Hangi byte'ları alacağınızı bilmek için neden kodlamayı belirtmiyorsunuz?

"Why is there a dependency on character encodings?"

Kodlama (bu bağlamda), dizenizi temsil eden baytlar anlamına gelir. Dize nesnesinin baytları değil. Dizenin saklandığı baytları istediniz - bu sorunun naif olarak sorulduğu yer. Dizenin baytını, dizeyi temsil eden bitişik bir dizide istediniz ve bir dize nesnesinin içerebileceği diğer tüm ikili verileri değil.

Bu, bir dizenin nasıl saklandığı anlamına gelmez. Bir bayt dizisindeki baytlara "Kodlanmış" bir dize istiyorsunuz.

Tom Bloget'in cevabını seviyorum çünkü sizi 'string nesnesinin bayt' yönüne doğru götürdü. Yine de uygulamaya bağlıdır ve iç kısımlara baktığı için dizenin bir kopyasını yeniden oluşturmak zor olabilir.

Mehrdad'ın yanıtı yanlıştır çünkü kavramsal düzeyde yanıltıcıdır. Hala kodlanmış bir bayt listeniz var. Onun özel çözümü, eşleştirilmemiş vekillerin korunmasına izin verir - bu uygulamaya bağlıdır. Özel çözümü, dizeyi GetBytesvarsayılan olarak UTF-8'de döndürürse dizenin baytlarını doğru bir şekilde üretmez .

Bununla ilgili fikrimi değiştirdim (Mehrdad'ın çözümü) - bu ipin baytlarını almıyor; bunun yerine dizeden oluşturulan karakter dizisinin baytını alıyor. Kodlamaya bakılmaksızın, c # 'daki char veri türü sabit bir boyuttur. Bu, tutarlı bir uzunluk bayt dizisinin üretilmesine izin verir ve karakter dizisinin bayt dizisinin boyutuna göre çoğaltılmasına izin verir. Kodlama UTF-8 olsaydı, ancak her karakter en büyük utf8 değerini barındırmak için 6 bayt olsaydı, yine de işe yarardı. Gerçekten de - karakterin kodlanması önemli değil.

Ancak bir dönüşüm kullanıldı - her karakter sabit boyutlu bir kutuya yerleştirildi (c # 'ın karakter tipi). Ancak bu temsilin önemi yoktur, teknik olarak OP'nin cevabı budur. Öyleyse - yine de dönüştürecekseniz ... Neden 'kodlamıyor'?

Aşağıdaki kodu stringkullanarak bir byte array.NET'e dönüştürmek için kullanabilirsiniz .

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

Bir dizenin temel alınan baytlarının bir kopyasını gerçekten istiyorsanız, aşağıdaki gibi bir işlev kullanabilirsiniz. Ancak, nedenini öğrenmek için lütfen okumaya devam etmemelisiniz .

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

Bu işlev, dizenizin altında yatan baytların bir kopyasını oldukça hızlı bir şekilde alır. Bu baytları sisteminizde hangi şekilde kodlarlarsa alacaksınız. Bu kodlama neredeyse kesinlikle UTF-16LE'dir, ancak bu, dikkat etmeniz gerekmeyen bir uygulama detayıdır.

Sadece aramak daha güvenli, daha basit ve daha güvenilir olurdu ,

System.Text.Encoding.Unicode.GetBytes()

Herhalde bu aynı sonucu verecektir, yazılması daha kolaydır ve baytlar her zaman bir çağrı ile

System.Text.Encoding.Unicode.GetString()

İşte benim güvensiz uygulamasıdır Stringiçin Byte[]dönüşüm:

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

Oldukça zarif olmasa bile, kabul edilen anws'ınkinden çok daha hızlı. İşte 10000000 iterasyonundaki Kronometre kriterlerim:

[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

Kullanmak için proje oluşturma özelliklerinizde "Güvenli Olmayan Kodlara İzin Ver" i işaretlemeniz gerekir. .NET Framework 3.5'e göre, bu yöntem Dize uzantısı olarak da kullanılabilir:

public static unsafe class StringExtensions
{
    public static Byte[] ToByteArray(this String s)
    {
        // Method Code
    }
}

Sadece şunu kullanın:

byte[] myByte= System.Text.ASCIIEncoding.Default.GetBytes(myString);

Dize, aşağıdaki durumdan dolayı birkaç farklı yolla bayt dizisine dönüştürülebilir: .NET, Unicode'u destekler ve Unicode, UTF adı verilen birkaç fark kodlamasını standart hale getirir. Farklı uzunluklarda bayt gösterimine sahiptirler, ancak bir dize kodlandığında, dizeye geri kodlanabilir, ancak dize bir UTF ile kodlanırsa ve vidalanabilirse farklı UTF varsayımıyla kodu çözülürse eşdeğerdir. yukarı.

Ayrıca, .NET Unicode olmayan kodlamaları destekler, ancak genel durumda geçerli değildir (yalnızca ASCII gibi gerçek bir dizede sınırlı bir Unicode kod noktası alt kümesi kullanılıyorsa geçerlidir). Dahili olarak .NET, UTF-16'yı destekler, ancak akış gösterimi için genellikle UTF-8 kullanılır. Aynı zamanda Internet için standart bir fiildir.

Şaşırtıcı olmayan bir şekilde, dizenin bir bayt ve serileştirme dizisine serileştirilmesi, System.Text.Encodingsoyut bir sınıf olan sınıf tarafından desteklenir ; türetilmiş sınıfları somut kodlamaları destekler: ASCIIEncodingve dört System.Text.UnicodeEncodingUTF ( UTF-16'yı destekler)

Bu bağlantıyı ref .

Kullanarak bir bayt dizisine serileştirme için System.Text.Encoding.GetBytes. Ters işlem için kullanın System.Text.Encoding.GetChars. Bu işlev bir karakter dizisi döndürür, bu nedenle bir dize almak için bir dize oluşturucu kullanın System.String(char[]).
Bu sayfayı ref.

Misal:

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? :-)

Baytların ne istediğine bağlıdır.

Bunun nedeni, Tyler'ın uygun şekilde dediği gibi , "Dizeler saf veri değil. Ayrıca bilgi var ." Bu durumda, bilgi, dize oluşturulduğunda varsayılan bir kodlamadır.

Bir dizede depolanmış ikili verileriniz (metin yerine) varsayarsak

Bu OP'nin kendi sorusuyla ilgili yorumunu temel alır ve OP'nin kullanım senaryosundaki ipuçlarını anlarsam doğru sorudur.

İkili verilerin dizelerde saklanması, yukarıda belirtilen varsayılan kodlama nedeniyle yanlış bir yaklaşımdır! Hangi program veya kütüphane bu ikili verileri string( byte[]daha uygun olacak bir dizi yerine) depolamışsa , savaş başlamadan önce savaşı kaybetmiştir. Baytları size bir REST isteği / yanıtı veya dizeleri iletmesi gereken herhangi bir şey olarak gönderiyorlarsa, Base64 doğru yaklaşım olacaktır.

Bilinmeyen kodlamaya sahip bir metin dizeniz varsa

Herkes bu yanlış soruyu yanlış cevapladı.

Dize olduğu gibi iyi görünüyorsa, sadece bir kodlama seçin (tercihen UTF ile başlayan bir kod), ilgili System.Text.Encoding.???.GetBytes()işlevi kullanın ve hangi kodlamayı seçtiğinize bayt verdiğinizi söyleyin.

Baytlarla ne yapmak istediğinizi sorduğunuzda, şu yanıtı verdiniz :

Şifreleyeceğim. Dönüştürmeden şifreleyebilirim ama yine de kodlamanın neden burada oynamaya geldiğini bilmek istiyorum. Sadece bana bayt ver dedim.

Bu şifrelenmiş verileri ağ üzerinden göndermek, daha sonra tekrar belleğe yüklemek veya başka bir işleme atmak isteyip istemediğinize bakılmaksızın, bir noktada şifresini çözmeyi planlıyorsunuz . Bu durumda cevap, bir iletişim protokolü tanımlamanızdır. Programlama dilinizin ve ilişkili çalışma zamanının uygulama ayrıntıları açısından bir iletişim protokolü tanımlanmamalıdır . Bunun birkaç nedeni vardır:

• Farklı bir dilde veya çalışma zamanında uygulanan bir işlemle iletişim kurmanız gerekebilir. (Örneğin, başka bir makinede çalışan veya dizeyi bir JavaScript tarayıcı istemcisine gönderen bir sunucu içerebilir.)
• Program gelecekte farklı bir dilde veya çalışma zamanında yeniden uygulanabilir.
• .NET uygulaması, dizelerin iç temsilini değiştirebilir. Kulağa çok uzak geldiğini düşünebilirsiniz, ancak bu aslında Java 9'da bellek kullanımını azaltmak için oldu . .NET'in davayı izlememesinin bir nedeni yoktur. Skeet, UTF-16'nın günümüzde muhtemelen en uygun olmadığını, iç temsilin gelecekte değişme olasılığını artırarak, temsil etmek için 2 bayttan daha fazlasına ihtiyaç duyan emoji ve diğer Unicode bloklarının yükselişini verdiğini ileri sürüyor .

İletişim kurmak için (tamamen farklı bir süreçle veya gelecekte aynı programla), onunla çalışma zorluğunu en aza indirmek veya yanlışlıkla hatalar oluşturmak için protokolünüzü kesinlikle tanımlamanız gerekir . .NET'in dahili temsiline bağlı olarak, tutarlı bir tanım olduğu kesin, net ve hatta garanti edilemez. Standart kodlama , gelecekte başarısız olmayacak katı bir tanımdır.

Başka bir deyişle, bir kodlama belirtmeden tutarlılık gereksiniminizi karşılayamazsınız .

Sen olabilir kesinlikle bulursanız doğrudan UTF-16 kullanmayı tercih senin süreç gerçekleştirdiği önemli ölçüde daha iyi .NET içten ya da başka herhangi bir nedenden dolayı kullanır, ancak açıkça kodlayan seçip bağlı daha kodunuzda açıkça bu dönüşümleri oldukça gerçekleştirmek için ihtiyaç beri .NET'in dahili uygulamasında.

Bu yüzden bir kodlama seçin ve kullanın:

using System.Text;

// ...

Encoding.Unicode.GetBytes("abc"); # UTF-16 little endian
Encoding.UTF8.GetBytes("abc")

Gördüğünüz gibi, sadece dahili kodlama nesnelerini kullanmak kendi okuyucu / yazıcı yöntemlerinizi uygulamaktan daha az koddur.

İki yol:

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

Ve,

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

Alttan yukarıdan daha sık kullanma eğilimindeyim, hız için kıyaslama yapmadım.

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