Conversione di array di byte in stringa e viceversa in C#

Question

Quindi, ecco l'affare: sto cercando di aprire un file (da byte), convertirlo in una stringa in modo da poter fare confusione con alcuni metadati nell'intestazione, convertirlo di nuovo a byte e salvarlo. Il problema che sto incontrando in questo momento è con questo codice. Quando confronto la stringa che è stata convertita avanti e indietro (ma non altrimenti modificata) nella matrice di byte originale, non è uguale. Come posso fare questo lavoro?

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

public string ByteArrayToString(byte[] input) 
{ 
    UTF8Encoding enc = new UTF8Encoding(); 
    string str = enc.GetString(input); 
    return str; 
} 

Ecco come li sto confrontando.

byte[] fileData = GetBinaryData(filesindir[0], Convert.ToInt32(fi.Length)); 
string fileDataString = ByteArrayToString(fileData); 
byte[] recapturedBytes = StringToByteArray(fileDataString); 
Response.Write((fileData == recapturedBytes)); 

Sono sicuro che è UTF-8, utilizzando:

StreamReader sr = new StreamReader(filesindir[0]); 
Response.Write(sr.CurrentEncoding); 

che restituisce "System.Text.UTF8Encoding".

Answer 1

Provare le funzioni statiche nella classe Encoding che fornisce istanze delle varie codifiche. Non è necessario istanziare lo Encoding solo per la conversione in/da un array di byte. Come stai confrontando le stringhe nel codice?

Modifica

si sta confrontando gli array, non stringhe. Sono disuguali perché si riferiscono a due diversi array; usando l'operatore == si confronteranno solo i loro riferimenti, non i loro valori. Dovrai ispezionare ogni elemento dell'array per determinare se sono equivalenti.

public bool CompareByteArrays(byte[] lValue, byte[] rValue) 
{ 
    if(lValue == rValue) return true; // referentially equal 
    if(lValue == null || rValue == null) return false; // one is null, the other is not 
    if(lValue.Length != rValue.Length) return false; // different lengths 

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

    return true; 
} 

Answer 2

Il tuo problema sembra essere il modo in cui si sta confrontando l'array di byte:

Response.Write((fileData == recapturedBytes)); 

questo sarà sempre return false in quanto si sta confrontando l'indirizzo della matrice di byte, non il valori che contiene Confrontare i dati della stringa o utilizzare un metodo per confrontare gli array di byte. Si potrebbe anche fare questo, invece:

Response.Write(Convert.ToBase64String(fileData) == Convert.ToBase64String(recapturedBytes)); 

Answer 3

A causa del fatto che le stringhe .NET utilizzano stringhe Unicode, non è più possibile fare questo la gente come ha fatto in C. Nella maggior parte dei casi, non si dovrebbe nemmeno tentativo a andare avanti e indietro dalla stringa < -> matrice di byte a meno che il contenuto non sia effettivamente testo.

devo chiarire questo punto: In .NET, se i dati non è byte[]testo, quindi non tentare di convertirlo in un string tranne che per la speciale Base64 codifica per i dati binari su un testo canale. Questo è un malinteso diffuso tra le persone che lavorano in .NET.

Answer 4

Quando si dispone di byte prime (8-bit caratteri forse-non-stampabili) e si desidera manipolarli come una stringa NET e li trasformano di nuovo in byte, è possibile farlo utilizzando

Encoding.GetEncoding(1252) 

invece di UTF8Encoding. Quella codifica funziona per prendere qualsiasi valore a 8 bit e convertirlo in un char .NET a 16 bit, e viceversa, senza perdere alcuna informazione.

Nel caso specifico descritto sopra, con un file binario, non sarà possibile "confondere i metadati nell'intestazione" e fare in modo che le cose funzionino correttamente, a meno che la lunghezza dei dati non sia cambiata. Ad esempio, se l'intestazione contiene

{any}{any}ABC{any}{any} 

e si desidera cambiare ABC a DEF, che dovrebbe funzionare come vuoi. Ma se vuoi cambiare ABC in WXYZ, dovrai scrivere sopra il byte che segue "C" o dovrai (in sostanza) spostare tutto di un byte più a destra. In un tipico file binario, ciò farà molto casino.

Se i byte dopo "ABC" sono spazi o caratteri nulli, c'è una migliore possibilità che la scrittura di dati di sostituzione più grandi non causi problemi - ma non è ancora possibile sostituire ABC con WXYZ nella stringa .NET, rendendolo più lungo - Dovresti sostituire ABC {whatever_follows_it} con WXYZ. Detto questo, potresti scoprire che è più semplice lasciare i dati come byte e scrivere i dati di sostituzione un byte alla volta.