Umwandeln byte-array in jeder base

Ein wenig spät zur party, aber...

Weil Ihre Spezifikation für eine beliebige Anzahl von bits, Sie müssen ein ganzzahliger Typ ist, kann mit einer beliebigen Anzahl von bits. Wenn Sie kann nicht als Ziel .NET 4.0 Sie müssen betteln, leihen oder stehlen ein BigInteger-Implementierung irgendwo (mag .NET 4.0 vielleicht).

public static class GenericBaseConverter
{
    public static string ConvertToString(byte[] valueAsArray, string digits, int pad)
    {
        if (digits == null)
            throw new ArgumentNullException("digits");
        if (digits.Length < 2)
            throw new ArgumentOutOfRangeException("digits", "Expected string with at least two digits");

        BigInteger value = new BigInteger(valueAsArray);
        bool isNeg = value < 0;
        value = isNeg ? -value : value;

        StringBuilder sb = new StringBuilder(pad + (isNeg ? 1 : 0));

        do
        {
            BigInteger rem;
            value = BigInteger.DivRem(value, digits.Length, out rem);
            sb.Append(digits[(int)rem]);
        } while (value > 0);

        //pad it
        if (sb.Length < pad)
            sb.Append(digits[0], pad - sb.Length);

        //if the number is negative, add the sign.
        if (isNeg)
            sb.Append('-');

        //reverse it
        for (int i = 0, j = sb.Length - 1; i < j; i++, j--)
        {
            char t = sb[i];
            sb[i] = sb[j];
            sb[j] = t;
        }

        return sb.ToString();

    }

    public static BigInteger ConvertFromString(string s, string digits)
    {
        BigInteger result;

        switch (Parse(s, digits, out result))
        {
            case ParseCode.FormatError:
                throw new FormatException("Input string was not in the correct format.");
            case ParseCode.NullString:
                throw new ArgumentNullException("s");
            case ParseCode.NullDigits:
                throw new ArgumentNullException("digits");
            case ParseCode.InsufficientDigits:
                throw new ArgumentOutOfRangeException("digits", "Expected string with at least two digits");
            case ParseCode.Overflow:
                throw new OverflowException();
        }

        return result;
    }

    public static bool TryConvertFromString(string s, string digits, out BigInteger result)
    {
        return Parse(s, digits, out result) == ParseCode.Success;
    }

    private enum ParseCode
    {
        Success,
        NullString,
        NullDigits,
        InsufficientDigits,
        Overflow,
        FormatError,
    }

    private static ParseCode Parse(string s, string digits, out BigInteger result)
    {
        result = 0;

        if (s == null)
            return ParseCode.NullString;
        if (digits == null)
            return ParseCode.NullDigits;
        if (digits.Length < 2)
            return ParseCode.InsufficientDigits;

        //skip leading white space
        int i = 0;
        while (i < s.Length && Char.IsWhiteSpace(s[i]))
            ++i;
        if (i >= s.Length)
            return ParseCode.FormatError;

        //get the sign if it's there.
        BigInteger sign = 1;
        if (s[i] == '+')
            ++i;
        else if (s[i] == '-')
        {
            ++i;
            sign = -1;
        }

        //Make sure there's at least one digit
        if (i >= s.Length)
            return ParseCode.FormatError;


        //Parse the digits.
        while (i < s.Length)
        {
            int n = digits.IndexOf(s[i]);
            if (n < 0)
                return ParseCode.FormatError;
            BigInteger oldResult = result;
            result = unchecked((result * digits.Length) + n);
            if (result < oldResult)
                return ParseCode.Overflow;

            ++i;
        }

        //skip trailing white space
        while (i < s.Length && Char.IsWhiteSpace(s[i]))
            ++i;

        //and make sure there's nothing else.
        if (i < s.Length)
            return ParseCode.FormatError;

        if (sign < 0)
            result = -result;

        return ParseCode.Success;
    }
}

Können Sie inspiration aus C# - Implementierung von Base32 Umsetzung von Michael Giagnocavo.

Weiteres Beispiel zu betrachten ist Ascii85, verwendet Adobe PostScript-und PDF-Dokumente. In Ascii85, 5 Zeichen codiert 4 bytes. Sie können herausfinden, die Effizienz der Codierung (256^4)/(85^5) = 96.8%. Dies ist der Bruchteil von bit-Kombinationen, die tatsächlich verwendet werden.

So, was auch immer die neue Basis, die Sie verwenden möchten, um die Verschlüsselung Ihrer Daten, die Sie schauen wollen, für eine Leistung zu bekommen, die es nur über eine Leistung von 256, wenn Sie versuchen zu maximieren kodiereffizienz. Das könnte nicht leicht werden für jede Basis. Überprüfung base 53 zeigt, dass das beste werden Sie wahrscheinlich bekommen, ist mit 7 zu kodierenden bytes 5 bytes (93.6% Wirkungsgrad), es sei denn, fühlen Sie sich wie mit 88 bytes zu Kodieren, 63 bytes.

Ein post auf CodeReview mich dazu veranlasst, zu erstellen RadixEncoding Klasse, die ist in der Lage, die Codierung/Decodierung ein byte-array zu/von einem base-N string.

Die Klasse gefunden werden kann in diesem Q&A thread, zusammen mit der Dokumentation auf (und Lösungen) ein paar Grenzfälle, die beim Umgang mit BigInteger, endian-ness-Unterstützung, und die Klasse' Gesamtleistung