Деление для BigInteger

Пишу собственный класс BigInteger, т.к стандартный использовать нельзя, да и нужно реализовать только деление с остатком BigInteger на числа 2, 8, 16(для перевода в сс с этими основаниями).

public class BigInteger
{
    private enum Sign
    {
        Positive = 1,
        Negative = -1
    }
    private byte[] digits;
    private Sign sign;
    public int Length { get; private set; }
    /// <summary>
    /// BigInteger constructor from string.
    /// </summary>
    public BigInteger(string str)
    {
        int add = 0;
        if (str[0] == '-')
        {
            sign = Sign.Negative;
            add++;
        }
        else
            sign = Sign.Positive;
        Length = str.Length - add;
        digits = new byte[Length];
        for (int i = 0; i < Length; i++)
            digits[digits.Length - i - 1] = (byte) (str[i + add] - '0');
    }
    /// <summary>
    /// BigInteger private constructor by digits number.
    /// Initializes with 0.
    /// </summary>
    private BigInteger(int length)
    {
        digits = new byte[length];
        Length = 1;
    }
    /// <summary>
    /// BigInteger copy constructor.
    /// </summary>
    public BigInteger(BigInteger other)
    {
        Length = other.Length;
        digits = new byte[Length];
        other.digits.CopyTo(digits, 0);
        sign = other.sign;
    }
    /// <summary>
    /// Convert BigInteger to string.
    /// </summary>
    public override string ToString()
    {
        var builder = new StringBuilder();
        if (sign == Sign.Negative)
            builder.Append('-');
        for (int j = Length - 1; j >= 0; j--)
            builder.Append(digits[j]);
        return builder.ToString();
    }
    /// <summary>
    /// Method for counting BigNumber length without leading zeroes.
    /// </summary>
    private int GetLength()
    {
        int length = digits.Length - 1;
        while (length > 0 && digits[length] == 0)
            length--;
        return length + 1;
    }
    /// <summary>
    /// Supplementary comparison of BigInteger absolute values.
    /// </summary>
    private int AbsCompare(BigInteger other)
    {
        if (Length != other.Length)
            return Length - other.Length;
        for (int i = Length - 1; i >= 0; i--)
            if (digits[i] != other.digits[i])
                return digits[i] - other.digits[i];
        return 0;
    }
    /// <summary>
    /// Comparison of BigInts.
    /// </summary>
    public int CompareTo(BigInteger other)
    {
        if (sign != other.sign)
            return other.sign - sign;
        return AbsCompare(other);
    }
}

Вот пока что написанный код. Как лучше всего хранить и использовать разные основания системы счислений(2, 8, 16) и реализовать метод деления(или есть алгоритмы перевода лучше?). Заранее спасибо!