11

(.NET の場合) byte[] (画像など)に任意のバイナリ データを格納しています。次に、そのデータを文字列(レガシー API の「コメント」フィールド)に格納する必要があります。このバイナリデータを文字列にパックするための標準的な手法はありますか? 「パッキング」とは、適度に大きくランダムなデータセットの場合、bytes.Length/2がpacked.Lengthとほぼ同じであることを意味します。2 バイトは多かれ少なかれ 1 文字であるためです。

2 つの「明白な」回答は、すべての基準を満たしていません。

string base64 = System.Convert.ToBase64String(bytes)

利用可能な約60,000文字のうち64文字しか使用しないため、文字列を非常に効率的に使用することはできません(私のストレージはSystem.Stringです)。一緒に行く

string utf16 = System.Text.Encoding.Unicode.GetString(bytes)

stringをより有効に活用できますが、無効な Unicode 文字 (サロゲート ペアの不一致など) を含むデータでは機能しません。 この MSDN の記事では、この正確な (貧弱な) 手法が示されています。

簡単な例を見てみましょう。

byte[] bytes = new byte[] { 0x41, 0x00, 0x31, 0x00};
string utf16 = System.Text.Encoding.Unicode.GetString(bytes);
byte[] utf16_bytes = System.Text.Encoding.Unicode.GetBytes(utf16);

この場合、元のバイトが UTF-16 文字列だったため、 bytesとutf16_bytesは同じです。これと同じ手順を base64 エンコーディングで実行すると、16 メンバーのbase64_bytes配列が得られます。

ここで、無効な UTF-16 データを使用して手順を繰り返します。

byte[] bytes = new byte[] { 0x41, 0x00, 0x00, 0xD8};

utf16_bytesが元のデータと一致しないことがわかります。

無効な Unicode 文字の前のエスケープとして U+FFFD を使用するコードを作成しました。それは機能しますが、自分で作ったものよりも標準的なテクニックがあるかどうか知りたい. 言うまでもなく、無効な文字を検出する方法としてDecoderFallbackExceptionをキャッチするのは好きではありません。

これを「ベース BMP」または「ベース UTF-16」エンコーディング (Unicode Basic Multilingual Plane のすべての文字を使用) と呼ぶことができると思います。はい、理想的には、Shawn Steele のアドバイスに従い、 byte[]を渡します。

Peter Housel の提案を「正しい」答えとして使用します。「標準的な手法」の提案に近づいたのは彼だけだからです。

base16k を編集するとさらに見栄えが良くなります。Jim Beveridge には実装があります。

4

7 に答える 7

12

base64を使用することをお勧めしますか? ストレージに関して最も効率的な方法ではないかもしれませんが、次の利点があります。

  1. コードに関するあなたの心配は終わりました。
  2. 他のプレイヤーとの互換性の問題があったとしても、その問題は最小限に抑えられます。
  3. 変換、エクスポート、インポート、バックアップ、復元などの際に、エンコードされた文字列が ASCII と見なされたとしても、問題はありません。
  4. 万が一あなたが死んだり、バスの下敷きになったりしたとしても、コメント フィールドを手に入れたプログラマなら誰でも、それが base64 であることを即座に認識し、すべてが暗号化されているなどとは思いません。
于 2009-03-19T14:43:18.687 に答える
3

まず、Unicode は 16 ビットを意味しないことを覚えておいてください。System.String が内部で UTF-16 を使用しているという事実は、ここにもありません。Unicode 文字は抽象的です。エンコーディングを通じてビット表現のみを取得します。

あなたは「私のストレージは System.String です」と言います - もしそうなら、ビットとバイトについて話すことはできず、Unicode 文字だけについて話すことはできません。System.String には確かに独自の内部エンコーディングがありますが、(理論的には) 異なる可能性があります。

ちなみに、System.String の内部表現は Base64 でエンコードされたデータに対してメモリ効率が低すぎると思われる場合は、ラテン語/西洋文字列についても心配しないのはなぜですか?

バイナリ データを System.String に格納する場合は、ビット コレクションと文字コレクションの間のマッピングが必要です。

オプション A: Base64 エンコーディングの形で事前に作成されたものがあります。ご指摘のとおり、これは 1 文字あたり 6 ビットのデータをエンコードします。

オプション B: 1 文字あたりのビット数を増やしたい場合は、128、256、512 などの Unicode 文字の配列 (またはエンコード) を作成し、1 文字あたり 7、8、9 などのビットのデータをパックする必要があります。キャラクター。これらの文字は、実際の Unicode 文字である必要があります。

あなたの質問に簡単に答えるには、はい、標準があります。それは Base64 エンコーディングです。

これは本当の問題ですか？Base64 を使用しないという考えを裏付けるパフォーマンス データはありますか?

于 2009-03-21T13:16:40.943 に答える
2

バイナリデータをUTF-8bとして扱うことができます。UTF-8bエンコーディングは、バイトがUTF-8マルチバイトシーケンスであると想定していますが、そうでないものにはフォールバックエンコーディングがあります。

于 2009-03-15T03:30:51.557 に答える
1

以下は、Jim Beveridge の C++実装の C# バージョンです。

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Linq;


//
// Base16k.cpp : Variant of base64 used to efficiently encode  binary into Unicode UTF16 strings. Based on work by
// Markus Scherer at https://sites.google.com/site/markusicu/unicode/base16k
//
// This code is hereby placed in the Public Domain.
// Jim Beveridge, November 29, 2011.
//
// C# port of http://qualapps.blogspot.com/2011/11/base64-for-unicode-utf16.html
// This code is hereby placed in the Public Domain.
// J. Daniel Smith, February 23, 2015
//

namespace JDanielSmith
{
    public static partial class Convert
    {
        /// <summary>
        /// Encode a binary array into a Base16k string for Unicode.
        /// </summary>
        public static string ToBase16kString(byte[] inArray)
        {
            int len = inArray.Length;

            var sb = new StringBuilder(len*6/5);
            sb.Append(len);

            int code = 0;

            for (int i=0; i<len; ++i)
            {
                byte byteValue = inArray[i];
                switch (i%7)
                {
                case 0:
                    code = byteValue<<6;
                    break;

                case 1:
                    code |= byteValue>>2;
                    code += 0x5000;
                    sb.Append(System.Convert.ToChar(code));
                    code = (byteValue&3)<<12;
                    break;

                case 2:
                    code |= byteValue<<4;
                    break;

                case 3:
                    code |= byteValue>>4;
                    code+=0x5000;
                    sb.Append(System.Convert.ToChar(code));
                    code = (byteValue&0xf)<<10;
                    break;

                case 4:
                    code |= byteValue<<2;
                    break;

                case 5:
                    code|=byteValue>>6;
                    code+=0x5000;
                    sb.Append(System.Convert.ToChar(code));
                    code=(byteValue&0x3f)<<8;
                    break;

                case 6:
                    code|=byteValue;
                    code+=0x5000;
                    sb.Append(System.Convert.ToChar(code));
                    code=0;
                    break;
                }
            }

            // emit a character for remaining bits
            if (len%7 != 0) {
                code += 0x5000;
                sb.Append(System.Convert.ToChar(code));
            }

            return sb.ToString();
        }

        /// <summary>
        ///  Decode a Base16k string for Unicode into a binary array.
        /// </summary>
        public static byte[] FromBase16kString(string s)
        {
            // read the length
            var r = new Regex(@"^\d+", RegexOptions.None, matchTimeout: TimeSpan.FromMilliseconds(100));
            Match m = r.Match(s);
            if (!m.Success)
                return null;

            int length;
            if (!Int32.TryParse(m.Value, out length))
                return null;

            var buf = new List<byte>(length);

            int pos=0;  // position in s
            while ((pos < s.Length) && (s[pos] >= '0' && s[pos] <= '9'))
                ++pos;

            // decode characters to bytes
            int i = 0;    // byte position modulo 7 (0..6 wrapping around)
            int code=0;
            byte byteValue=0;

            while (length-- > 0)
            {
                if (((1<<i)&0x2b)!=0)
                {
                    // fetch another Han character at i=0, 1, 3, 5
                    if(pos >= s.Length)
                    {
                        // Too few Han characters representing binary data.
                        System.Diagnostics.Debug.Assert(pos < s.Length);
                        return null;
                    }

                    code=s[pos++]-0x5000;
                }

                switch (i%7)
                {
                case 0:
                    byteValue = System.Convert.ToByte(code>>6);
                    buf.Add(byteValue);
                    byteValue = System.Convert.ToByte((code&0x3f)<<2);
                    break;

                case 1:
                    byteValue |= System.Convert.ToByte(code>>12);
                    buf.Add(byteValue);
                    break;

                case 2:
                    byteValue = System.Convert.ToByte((code>>4)&0xff);
                    buf.Add(byteValue);
                    byteValue = System.Convert.ToByte((code&0xf)<<4);
                    break;

                case 3:
                    byteValue |= System.Convert.ToByte(code>>10);
                    buf.Add(byteValue);
                    break;

                case 4:
                    byteValue = System.Convert.ToByte((code>>2)&0xff);
                    buf.Add(byteValue);
                    byteValue = System.Convert.ToByte((code&3)<<6);
                    break;

                case 5:
                    byteValue |= System.Convert.ToByte(code>>8);
                    buf.Add(byteValue);
                    break;

                case 6:
                    byteValue = System.Convert.ToByte(code&0xff);
                    buf.Add(byteValue);
                    break;
                }

                // advance to the next byte position
                if(++i==7)
                    i=0;
            }

            return buf.ToArray();
        }
    }
}

namespace Base16kCS
{
    class Program
    {
        static void Main(string[] args)
        {
            var drand = new Random();

            // Create 500 different binary objects, then encode and decode them.
            // The first 16 objects will have length 0,1,2 ... 16 to test boundary conditions.
            for (int loop = 0; loop < 500; ++loop)
            {
                Console.WriteLine("{0}", loop);

                int dw = drand.Next(128000);
                var org = new List<byte>(dw);
                for (int i = 0; i < dw; ++i)
                    org.Add(Convert.ToByte(drand.Next(256)));

                if (loop < 16)
                    org = org.Take(loop).ToList();

                string wstr = JDanielSmith.Convert.ToBase16kString(org.ToArray());

                byte[] bin = JDanielSmith.Convert.FromBase16kString(wstr);

                System.Diagnostics.Debug.Assert(org.SequenceEqual(bin));
            }
        }
    }
}
于 2015-02-24T16:03:31.790 に答える
0

私は直接のchar配列をいじりました.1つの失敗したケースは私の実装で機能します. コードは十分にテストされています。最初にテストを行ってください。

安全でないコードを使用すると、これを高速化できます。しかし、UnicodeEncoding も同じくらい遅いと確信しています (遅くはないにしても)。

/// <summary>
/// Represents an encoding that packs bytes tightly into a string.
/// </summary>
public class ByteEncoding : Encoding
{
    /// <summary>
    /// Gets the Byte Encoding instance.
    /// </summary>
    public static readonly Encoding Encoding = new ByteEncoding();

    private ByteEncoding()
    {
    }

    public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
    {
        for (int i = 0; i < chars.Length; i++)
        {
            // Work out some indicies.
            int j = i * 2;
            int k = byteIndex + j;

            // Get the bytes.
            byte[] packedBytes = BitConverter.GetBytes((short) chars[charIndex + i]);

            // Unpack them.
            bytes[k] = packedBytes[0];
            bytes[k + 1] = packedBytes[1];
        }

        return chars.Length * 2;
    }

    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
    {
        for (int i = 0; i < byteCount; i += 2)
        {
            // Work out some indicies.
            int j = i / 2;
            int k = byteIndex + i;

            // Make sure we don't read too many bytes.
            byte byteB = 0;
            if (i + 1 < byteCount)
            {
                byteB = bytes[k + 1];
            }

            // Add it to the array.
            chars[charIndex + j] = (char) BitConverter.ToInt16(new byte[] { bytes[k], byteB }, 0);
        }

        return (byteCount / 2) + (byteCount % 2); // Round up.
    }

    public override int GetByteCount(char[] chars, int index, int count)
    {
        return count * 2;
    }

    public override int GetCharCount(byte[] bytes, int index, int count)
    {
        return (count / 2) + (count % 2);
    }

    public override int GetMaxByteCount(int charCount)
    {
        return charCount * 2;
    }

    public override int GetMaxCharCount(int byteCount)
    {
        return (byteCount / 2) + (byteCount % 2);
    }
}

ここにいくつかのテストコードがあります:

    static void Main(string[] args)
    {
        byte[] original = new byte[256];

        // Note that we can't tell on the decode side how
        // long the array was if the original length is
        // an odd number. This will result in an
        // inconclusive result.
        for (int i = 0; i < original.Length; i++)
            original[i] = (byte) Math.Abs(i - 1);

        string packed = ByteEncoding.Encoding.GetString(original);
        byte[] unpacked = ByteEncoding.Encoding.GetBytes(packed);

        bool pass = true;

        if (original.Length != unpacked.Length)
        {
            Console.WriteLine("Inconclusive: Lengths differ.");
            pass = false;
        }

        int min = Math.Min(original.Length, unpacked.Length);
        for (int i = 0; i < min; i++)
        {
            if (original[i] != unpacked[i])
            {
                Console.WriteLine("Fail: Invalid at a position {0}.", i);
                pass = false;
            }
        }

        Console.WriteLine(pass ? "All Passed" : "Failure Present");

        Console.ReadLine();
    }

テストは機能しますが、API 関数でテストする必要があります。

于 2009-03-19T10:04:33.270 に答える
0

この制限を回避する別の方法があります。ただし、どの程度うまく機能するかはわかりません。

まず、API 呼び出しが想定している文字列のタイプと、この文字列の構造を把握する必要があります。簡単な例を挙げると、.Net 文字列を考えてみましょう。

  • Int32 _length;
  • バイト[] _data;
  • バイト _ターミネータ = 0;

次のように、API 呼び出しにオーバーロードを追加します。

[DllImport("legacy.dll")]
private static extern void MyLegacyFunction(byte[] data);

[DllImport("legacy.dll")]
private static extern void MyLegacyFunction(string comment);

次に、バイトバージョンを呼び出す必要がある場合は、次のことができます。

    public static void TheLegacyWisperer(byte[] data)
    {
        byte[] realData = new byte[data.Length + 4 /* _length */ + 1 /* _terminator */ ];
        byte[] lengthBytes = BitConverter.GetBytes(data.Length);
        Array.Copy(lengthBytes, realData, 4);
        Array.Copy(data, 0, realData, 4, data.Length);
        // realData[end] is equal to 0 in any case.
        MyLegacyFunction(realData);
    }
于 2009-03-19T10:26:13.030 に答える