Comment convertir une chaîne de bits de tableau d'octets

J'ai une chaîne de caractères représentant bits, tels que:

"0000101000010000"

Je veux le convertir pour obtenir un tableau d'octets, tels que:

{0x0A, 0x10}

Le nombre d'octets est variable, mais il y aura toujours un rembourrage de 8 bits par octet (donc 1010 devient 000010101).

OriginalL'auteur Roast | 2010-06-07

  1. 8

    Utilisez le builtin Convertir.ToByte() et de lire en morceaux de 8 caractères, sans réinventer la chose..

    Sauf si c'est quelque chose qui devrait vous enseigner au sujet des opérations bit à bit.

    Mise à jour:

    Voler à partir d'Adam (et la surutilisation de LINQ, probablement. Ce qui pourrait être trop concis et de normal de la boucle peut-être mieux, en fonction de votre propre (et votre collègue!) préférences):

    public static byte[] GetBytes(string bitString) {
    return Enumerable.Range(0, bitString.Length/8).
        Select(pos => Convert.ToByte(
            bitString.Substring(pos*8, 8),
            2)
        ).ToArray();
}
    Alors que je serais favorable à ce que, le seul problème est qu'une très longue chaîne de bits (bien que j'aurais à me demander pourquoi vous devez en premier lieu) sera dans un très grand nombre de sous-chaînes.
    C'est probablement ce que je vais aller avec. Après j'ai formulé la question, j'ai réalisé que le fait d'aller à travers la chaîne en morceaux de 8 caractères serait plus facile. La chaîne sera susceptible de représenter de 10 à 12 octets, de sorte que le coût en temps d'exécution n'est pas grande. Une fois, je confirme que tout fonctionne mal donne une mise à jour
    Tout comme un site note, dans mes tests, le Linq exemple est très légèrement plus lente que celle de la boucle de la solution fournie par @AdamRobinson

    OriginalL'auteur Benjamin Podszun

  2. 2
    public static byte[] GetBytes(string bitString)
{
    byte[] output = new byte[bitString.Length / 8];

    for (int i = 0; i < output.Length; i++)
    {
        for (int b = 0; b <= 7; b++)
        {
            output[i] |= (byte)((bitString[i * 8 + b] == '1' ? 1 : 0) << (7 - b));
        }
    }

    return output;
}
    bitString.Longueur / 8 ne sera pas toujours round up. Si vous passez dans "010" que la chaîne, le tableau retourné aura une longueur de 0.
    Vous avez tout à fait raison, en fait ça sera toujours rond le (division entière tronque le reste, il n'a pas rond). Cependant, l'OP dit explicitement que les chaînes de caractères contenant une pleine huit bits par octet.
    Elle n'est pas explicite sur l'endroit où le rembourrage est fait, en fait. J'ai assumé la fonction serait d'accepter les petites chaînes. Elle peut dire que la fonction va recevoir un collier de chaînes. Veut-elle la fonction pour ignorer en silence des chaînes plus longues qui ne font pas le plein 8 bits? Silencieusement, faisant abstraction de données ne tient droit avec moi. Si sa garantie pour être divisible par 8, il ne serait pas mal que ce soit clair avec une assertion ou d'une exception ou d'une chose. Tout ceci est pertinent de se regarder le nombril, à ce point, vraiment, bien. 🙂
    Reconnaissant le regarder le nombril qui se passe ici, "...sera toujours rembourrage de forme 8 bits par octet (donc 1010 devient 000010101)." il semble, dit assez clairement qu'il y a...sera toujours 8 bits par octet. 😉
    La déclaration ci-dessus à partir d'Adam est correct. Je ne vais pas entrer dans une explication entière de ce programme, mais il est sûr de supposer que chaque octet aura un entier de 8 bits.

    OriginalL'auteur Adam Robinson

  3. 2

    Voici un moyen rapide et simple de la solution (et je pense qu'il répondra à toutes vos exigences): http://vbktech.wordpress.com/2011/07/08/c-net-converting-a-string-of-bits-to-a-byte-array/

    OriginalL'auteur VBK

  4. 0

    Cela devrait vous obtenez pour votre réponse: Comment puis-je convertir des bits des octets?

    Vous pourriez convertir votre chaîne en un tableau, par exemple, que l'article a, et à partir de là utiliser la même logique pour effectuer la conversion.

    OriginalL'auteur Andrew Anderson

  5. 0

    Obtenir le characers en groupes de huit, et d'analyser à un octet:

    string bits = "0000101000010000";

byte[] data =
  Regex.Matches(bits, ".{8}").Cast<Match>()
  .Select(m => Convert.ToByte(m.Groups[0].Value, 2))
  .ToArray();
    Ouch. Une regex juste pour lire tous les N (=8) caractères? Fonctionne, mais il semble abusif de moi..
    Oui, il a peu de frais généraux, mais c'est un simple moyen de couper une chaîne de caractères et il fonctionne assez bien pour la plupart des besoins. Ayant bits en une chaîne de caractères ne semble pas comme un scénario où la performance la plus élevée est requise de toute façon...
    Le scénario est d'une drôle de patch pour importer un ancien format de fichier, enregistré avec un prototype de programme il y a des années. Les données doivent être appliqués dans les nouveaux programmes de la structure de données. Les fichiers ne sont pas si grande, et cette fonction ne sera pas utilisée trop souvent, de sorte que la performance n'est pas un problème.

    OriginalL'auteur Guffa

  6. 0
    private static byte[] GetBytes(string bitString)
{
    byte[] result = Enumerable.Range(0, bitString.Length / 8).
        Select(pos => Convert.ToByte(
            bitString.Substring(pos * 8, 8),
            2)
        ).ToArray();

    List<byte> mahByteArray = new List<byte>();
    for (int i = result.Length - 1; i >= 0; i--)
    {
        mahByteArray.Add(result[i]);
    }

    return mahByteArray.ToArray();
}

private static String ToBitString(BitArray bits)
{
    var sb = new StringBuilder();

    for (int i = bits.Count - 1; i >= 0; i--)
    {
        char c = bits[i] ? '1' : '0';
        sb.Append(c);
    }

    return sb.ToString();
}

    OriginalL'auteur drayv

  7. -2

    Vous pouvez aller de ci-dessous,

            byte []bytes = System.Text.Encoding.UTF8.GetBytes("Hi");
        string str = System.Text.Encoding.UTF8.GetString(bytes);


        byte []bytesNew = System.Convert.FromBase64String ("Hello!");
        string strNew = System.Convert.ToBase64String(bytesNew);
    La question était sur la conversion d'une chaîne de caractères représentant bits pour un tableau d'octets représentant la valeur de ces bits. Votre solution n'a pas de réponse à cette question.
    Merci pour le partage de ce - que c'est exactement ce que je cherchais. Beaucoup d'entre nous recherche par le biais de ces fils, à la recherche de solutions qui pourraient ne pas correspondre à 100% à la question initiale, mais contiennent des idées utiles.

    OriginalL'auteur khokhani1510