/// <summary>

    /// 从M进制转换为N进制

    /// </summary>

    internal class MBase2NBase

    {

        /// <summary>

        /// M进制值字符串

        /// </summary>

        private string MValue = "";

        /// <summary>

        /// 除法商

        /// </summary>

        private string Quotient = null;

        /// <summary>

        /// M进制

        /// </summary>

        private int M = ;

        /// <summary>

        /// N进制

        /// </summary>

        private int N = ;

        /// <summary>

        /// .ctor

        /// </summary>

        public MBase2NBase()

        {

        }

        /// <summary>

        /// .ctor

        /// </summary>

        /// <param name="mValue">M进制值字符串</param>

        /// <param name="m">M进制(如10).参数值在2~36的范围内</param>

        /// <param name="n">N进制(如8),则意味着从10进制转换成8进制.参数值在2~36的范围内</param>

        public MBase2NBase(string mValue, int m, int n)

        {

            this.M = m;

            this.N = n;

            this.MValue = mValue;

        }

        /// <summary>

        /// 开始转换

        /// </summary>

        /// <param name="mValue">M进制值字符串</param>

        /// <param name="m">M进制(如10).参数值在2~36的范围内</param>

        /// <param name="n">N进制(如8),则意味着从10进制转换成8进制.参数值在2~36的范围内</param>

        /// <returns>N进制字符串</returns>

        public string Transform(string mValue, int m, int n)

        {

            this.M = m;

            this.N = n;

            this.MValue = mValue;

            return Transform();

        }

        /// <summary>

        /// M进制值字符串

        /// </summary>

        /// <returns>N进制字符串</returns>

        public string Transform()

        {

            if (M <  || M > )

            {

                throw new ArgumentOutOfRangeException("参数值不在2~36的范围内");

            }

            if (N <  || N > )

            {

                throw new ArgumentOutOfRangeException("参数值不在2~36的范围内");

            }

            if (M == N)

            {

                return MValue;

            }

            String nValue = "";

            Quotient = MValue;

            while (Quotient.Length > )

            {

                nValue = Remainder(Quotient) + nValue;

            }

            return nValue;

        }

        /// <summary>

        /// 对给定的M进制字符串对n求余

        /// </summary>

        /// <param name="mTempValue"></param>

        /// <returns></returns>

        private String Remainder(String mTempValue)

        {

            Quotient = "";

            int temp = ;

            while (mTempValue.Length > )

            {

                int t = GetIntFromStringFirstChar(mTempValue.Substring(, ));

                mTempValue = mTempValue.Substring();

                temp = temp*M + t;

                Quotient += GetStrFromInt(temp / N);

                temp = temp%N;

            }

            while (Quotient.Length >  && Quotient[] == '')

            {

                Quotient = Quotient.Substring();

            }

            return GetStrFromInt(temp);

        }

        /// <summary>

        /// 字符串转换成Int

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        private int GetIntFromStringFirstChar(String str)

        {

            return str[] <= '' && str[] >= '' ? str[] - '' : str[] - 'a' + ;

        }

        /// <summary>

        /// Int转换为相应进制的字符

        /// </summary>

        /// <param name="value"></param>

        /// <returns></returns>

        private String GetStrFromInt(int value)

        {

            String result = null;

            if (value >=  && value <= )

                result = ((char) ('' + value)).ToString();

            else if (value >  && value < )

            {

                result = ((char) ('a' + value - )).ToString();

            }

            else

            {

                throw new Exception("未知错误");

            }

            return result;

        }

    }