十进制，八进制，十六进制，二进制相互转换
' 用途：将十进制转化为二进
' 输入：Dec(十进制数)
' 输入数据类型：Long
' 输出：DEC_to_BIN(二进制数)
' 输出数据类型：String
' 输入的最大数为2147483647,输出最大数为1111111111111111111111111111111(31个1)
Public Function DEC_to_BIN(Dec As Long) As String
DEC_to_BIN = ""
Do While Dec > 0
DEC_to_BIN = Dec Mod 2 & DEC_to_BIN
Dec = Dec \ 2
Loop
End Function
' 用途：将二进制转化为十进制
' 输入：Bin(二进制数)
' 输入数据类型：String
' 输出：BIN_to_DEC(十进制数)
' 输出数据类型：Long
' 输入的最大数为1111111111111111111111111111111(31个1),输出最大数为2147483647
Public Function BIN_to_DEC(ByVal Bin As String) As Long
Dim i As Long
For i = 1 To Len(Bin)
BIN_to_DEC = BIN_to_DEC * 2 + Val(Mid(Bin, i, 1))
Next i
End Function
' 用途：将十六进制转化为二进制
' 输入：Hex(十六进制数)
' 输入数据类型：String
' 输出：HEX_to_BIN(二进制数)
' 输出数据类型：String
' 输入的最大数为2147483647个字符
Public Function HEX_to_BIN(ByVal Hex As String) As String
Dim i As Long
Dim B As String
Hex = UCase(Hex)
For i = 1 To Len(Hex)
Select Case Mid(Hex, i, 1)
Case "0": B = B & "0000"
Case "1": B = B & "0001"
Case "2": B = B & "0010"
Case "3": B = B & "0011"
Case "4": B = B & "0100"
Case "5": B = B & "0101"
Case "6": B = B & "0110"
Case "7": B = B & "0111"
Case "8": B = B & "1000"
Case "9": B = B & "1001"
Case "A": B = B & "1010"
Case "B": B = B & "1011"
Case "C": B = B & "1100"
Case "D": B = B & "1101"
Case "E": B = B & "1110"
Case "F": B = B & "1111"
End Select
Next i
While Left(B, 1) = "0"
B = Right(B, Len(B) - 1)
Wend
HEX_to_BIN = B
End Function
' 用途：将二进制转化为十六进制
' 输入：Bin(二进制数)
' 输入数据类型：String
' 输出：BIN_to_HEX(十六进制数)
' 输出数据类型：String
' 输入的最大数为2147483647个字符
Public Function BIN_to_HEX(ByVal Bin As String) As String
Dim i As Long
Dim H As String
If Len(Bin) Mod 4 <> 0 Then
Bin = String(4 - Len(Bin) Mod 4, "0") & Bin
End If
For i = 1 To Len(Bin) Step 4
Select Case Mid(Bin, i, 4)
Case "0000": H = H & "0"
Case "0001": H = H & "1"
Case "0010": H = H & "2"
Case "0011": H = H & "3"
Case "0100": H = H & "4"
Case "0101": H = H & "5"
Case "0110": H = H & "6"
Case "0111": H = H & "7"
Case "1000": H = H & "8"
Case "1001": H = H & "9"
Case "1010": H = H & "A"
Case "1011": H = H & "B"
Case "1100": H = H & "C"
Case "1101": H = H & "D"
Case "1110": H = H & "E"
Case "1111": H = H & "F"
End Select
Next i
While Left(H, 1) = "0"
H = Right(H, Len(H) - 1)
Wend
BIN_to_HEX = H
End Function
' 用途：将十六进制转化为十进制
' 输入：Hex(十六进制数)
' 输入数据类型：String
' 输出：HEX_to_DEC(十进制数)
' 输出数据类型：Long
' 输入的最大数为7FFFFFFF,输出的最大数为2147483647
Public Function HEX_to_DEC(ByVal Hex As String) As Long
Dim i As Long
Dim B As Long
Hex = UCase(Hex)
For i = 1 To Len(Hex)
Select Case Mid(Hex, Len(Hex) - i + 1, 1)
Case "0": B = B + 16 ^ (i - 1) * 0
Case "1": B = B + 16 ^ (i - 1) * 1
Case "2": B = B + 16 ^ (i - 1) * 2
Case "3": B = B + 16 ^ (i - 1) * 3
Case "4": B = B + 16 ^ (i - 1) * 4
Case "5": B = B + 16 ^ (i - 1) * 5
Case "6": B = B + 16 ^ (i - 1) * 6
Case "7": B = B + 16 ^ (i - 1) * 7
Case "8": B = B + 16 ^ (i - 1) * 8
Case "9": B = B + 16 ^ (i - 1) * 9
Case "A": B = B + 16 ^ (i - 1) * 10
Case "B": B = B + 16 ^ (i - 1) * 11
Case "C": B = B + 16 ^ (i - 1) * 12
Case "D": B = B + 16 ^ (i - 1) * 13
Case "E": B = B + 16 ^ (i - 1) * 14
Case "F": B = B + 16 ^ (i - 1) * 15
End Select
Next i
HEX_to_DEC = B
End Function
' 用途：将十进制转化为十六进制
' 输入：Dec(十进制数)
' 输入数据类型：Long
' 输出：DEC_to_HEX(十六进制数)
' 输出数据类型：String
' 输入的最大数为2147483647,输出最大数为7FFFFFFF
Public Function DEC_to_HEX(Dec As Long) As String
Dim a As String
DEC_to_HEX = ""
Do While Dec > 0
a = CStr(Dec Mod 16)
Select Case a
Case "10": a = "A"
Case "11": a = "B"
Case "12": a = "C"
Case "13": a = "D"
Case "14": a = "E"
Case "15": a = "F"
End Select
DEC_to_HEX = a & DEC_to_HEX
Dec = Dec \ 16
Loop
End Function
' 用途：将十进制转化为八进制
' 输入：Dec(十进制数)
' 输入数据类型：Long
' 输出：DEC_to_OCT(八进制数)
' 输出数据类型：String
' 输入的最大数为2147483647,输出最大数为17777777777
Public Function DEC_to_OCT(Dec As Long) As String
DEC_to_OCT = ""
Do While Dec > 0
DEC_to_OCT = Dec Mod 8 & DEC_to_OCT
Dec = Dec \ 8
Loop
End Function
' 用途：将八进制转化为十进制
' 输入：Oct(八进制数)
' 输入数据类型：String
' 输出：OCT_to_DEC(十进制数)
' 输出数据类型：Long
' 输入的最大数为17777777777,输出的最大数为2147483647
Public Function OCT_to_DEC(ByVal Oct As String) As Long
Dim i As Long
Dim B As Long
For i = 1 To Len(Oct)
Select Case Mid(Oct, Len(Oct) - i + 1, 1)
Case "0": B = B + 8 ^ (i - 1) * 0
Case "1": B = B + 8 ^ (i - 1) * 1
Case "2": B = B + 8 ^ (i - 1) * 2
Case "3": B = B + 8 ^ (i - 1) * 3
Case "4": B = B + 8 ^ (i - 1) * 4
Case "5": B = B + 8 ^ (i - 1) * 5
Case "6": B = B + 8 ^ (i - 1) * 6
Case "7": B = B + 8 ^ (i - 1) * 7
End Select
Next i
OCT_to_DEC = B
End Function
' 用途：将二进制转化为八进制
' 输入：Bin(二进制数)
' 输入数据类型：String
' 输出：BIN_to_OCT(八进制数)
' 输出数据类型：String
' 输入的最大数为2147483647个字符
Public Function BIN_to_OCT(ByVal Bin As String) As String
Dim i As Long
Dim H As String
If Len(Bin) Mod 3 <> 0 Then
Bin = String(3 - Len(Bin) Mod 3, "0") & Bin
End If
For i = 1 To Len(Bin) Step 3
Select Case Mid(Bin, i, 3)
Case "000": H = H & "0"
Case "001": H = H & "1"
Case "010": H = H & "2"
Case "011": H = H & "3"
Case "100": H = H & "4"
Case "101": H = H & "5"
Case "110": H = H & "6"
Case "111": H = H & "7"
End Select
Next i
While Left(H, 1) = "0"
H = Right(H, Len(H) - 1)
Wend
BIN_to_OCT = H
End Function
' 用途：将八进制转化为二进制
' 输入：Oct(八进制数)
' 输入数据类型：String
' 输出：OCT_to_BIN(二进制数)
' 输出数据类型：String
' 输入的最大数为2147483647个字符
Public Function OCT_to_BIN(ByVal Oct As String) As String
Dim i As Long
Dim B As String
For i = 1 To Len(Oct)
Select Case Mid(Oct, i, 1)
Case "0": B = B & "000"
Case "1": B = B & "001"
Case "2": B = B & "010"
Case "3": B = B & "011"
Case "4": B = B & "100"
Case "5": B = B & "101"
Case "6": B = B & "110"
Case "7": B = B & "111"
End Select
Next i
While Left(B, 1) = "0"
B = Right(B, Len(B) - 1)
Wend
OCT_to_BIN = B
End Function
' 用途：将八进制转化为十六进制
' 输入：Oct(八进制数)
' 输入数据类型：String
' 输出：OCT_to_HEX(十六进制数)
' 输出数据类型：String
' 输入的最大数为2147483647个字符
Public Function OCT_to_HEX(ByVal Oct As String) As String
Dim Bin As String
Bin = OCT_to_BIN(Oct)
OCT_to_HEX = BIN_to_HEX(Bin)
End Function
' 用途：将十六进制转化为八进制
' 输入：Hex(十六进制数)
' 输入数据类型：String
' 输出：HEX_to_OCT(八进制数)
' 输出数据类型：String
' 输入的最大数为2147483647个字符
Public Function HEX_to_OCT(ByVal Hex As String) As String
Dim Bin As String
Hex = UCase(Hex)
Bin = HEX_to_BIN(Hex)
HEX_to_OCT = BIN_to_OCT(Bin)
End Function
VB自带函数：
十进制转八进制：Oct(num)
十六进制转八进制：oct("&H" & num)
十进制转十六进制：hex(num)
八进制转十六进制：hex("&O" & num)
十六进制转换为十进制
Dim str As String
str = Text2.Text
Text10.Text = CLng("&H" & str)
文章出处：http://blog.programfan.com/article.asp?id=11903
感谢作者的无私奉献、、、、

在.NET Framework中，System.Convert类中的ToString方法和ToInt32（ToInt64）方法都可以方便的实现各种进制间的相互转换。
1、Convert .ToString 方法
Convert .ToString 方法可以将整数值转换为其指定基数（必须是 2、8、10 或 16）的等效字符串表示形式。即可以将十进制整数转换成二进制、八进制、十进制（无实际意义）或十六进制数字的字符串。

Convert .ToString（value，toBase）

参数：value——整型，要转换的整数；toBase—— System .Int32 ，返回值的基数，必须是 2、8、10 或 16。

返回值：System .String ，以 toBase 为基的 value 的字符串表示形式。

如：
        Dim int As Integer = 256
        '十进制转二进制
        Dim str2 As String = Convert.ToString(int, 2)
        '十进制转八进制
        Dim str8 As String = Convert.ToString(int, 8)
        '十进制转十进制
        Dim str10 As String = Convert.ToString(int, 10)
        '十进制转十六进制
        Dim str16 As String = Convert.ToString(int, 16)
        Console.WriteLine("十进制转二进制：" & str2)
        Console.WriteLine("十进制转八进制：" & str8)
        Console.WriteLine("十进制转十进制：" & str10)
        Console.WriteLine("十进制转十六进制：" & str16)

测试结果如图：


2、Convert .ToInt32（ToInt64） 方法
将指定基数的数字的字符串表示形式转换为等效的整数。即可以将二进制、八进制、十进制（无实际意义）或十六进制整数的字符串表示形式转换为十进制的数字（整型）。

Convert .ToUInt64（value，fromBase）

参数：value—— System .String ，包含要转换的数字的字符串；fromBase——System .Int32 ，value 中数字的基数，它必须是 2、8、10 或 16。

返回值：整型，与 value 中数字等效的 整数，如果 value 为 Nothing，则为 0（零）。

如：
        '二进制
        Dim str2 As String = "100000000"
        '八进制
        Dim str8 As String = "400"
        '十六进制
        Dim str16 As String = "100"

        '二进制转十进制
        Dim int2 As Integer = Convert.ToInt32(str2, 2)
        '八进制转十进制
        Dim int8 As Integer = Convert.ToInt32(str8, 8)
        '十六进制转十进制
        Dim int16 As Integer = Convert.ToInt32(str16, 16)

3、二进制、八进制、十进制或十六进制间任意互转（输出字符串）
先把字符串转换成十进制数字，再把数字转换成其他进制的字符串。
    Sub Main()
        '二进制
        Dim str2 As String = "100000000"
        '八进制
        Dim str8 As String = "400"
        '十六进制
        Dim str16 As String = "100"

        '二进制转十六进制
        Dim str2to16 As String = ConvertString(str2, 2, 16)
        '八进制转十六进制
        Dim str8to16 As String = ConvertString(str8, 8, 16)
        '十六进制转二进制
        Dim str16to2 As String = ConvertString(str16, 16, 2)
    End Sub
    ''' <summary>
    ''' 进制转换
    ''' </summary>
    ''' <param name="value">二进制、八进制、十进制或十六进制整数的字符串表示形式</param>
    ''' <param name="fromBase">与value值中的相对应的基数（2、8、10或16）</param>
    ''' <param name="toBase">要转换成的进制基数（2、8、10或16）</param>
    ''' <returns></returns>
    Private Function ConvertString(ByVal value As String, ByVal fromBase As Int32, ByVal toBase As Int32) As String
        Dim intValue As Integer = Convert.ToInt32(value, fromBase)

        Return Convert.ToString(intValue, toBase)
    End Function

4、其他进制转换方法
Object.ToString方法或String.Format方法可以将十进制整数转换成十六进制的数字字符串表现形式，但没有提供其他进制的转换。

如：
        Dim int As Integer = 256
        Dim strS As String = int.ToString("x")
        Dim strF As String = String.Format("{0:x}", int)

5、进制基础知识
比如十进制的15，其二进制为1111，八进制为17，而16进制为F，各种进制之间是如何转换的呢？
（1）二进制、八进制、十六进制转十进制


可见，在十进制中，每一位表示10的幂，要知道十进制位所代表的具体数字，可以将相应数字乘以10的幂，然后把结果相加。

按照同样的方法，二进制中，每一位表示2的幂，则应将数字乘以2的幂，然后把结果相加即可得到相应的十进制数。

依此类推，八进制和十六进制都可以按此方法转换为十进制。
（2）十进制转二进制、八进制、十六进制
方法：除相应进制的基数（如二进制的基数为2、八进制的基数为8、十六进制的基数为16）取余法，即每次将整数部分除以基数，余数为该位权上的数，而商继续除以基数，余数又为上一个位权上的数，这个步骤一直持续下去，直到商为0为止，最后读数时候，从最后一个余数读起，一直到最前面的一个余数。

例：将十进制的(15)转换为二进制的步骤如下：

将商15除以2，商7余数为1；
将商7除以2，商3余数为1；
将商3除以2，商1余数为1；
将商1除以2，商0余数为1；
读数，读数字从最后的余数向前读，1111。

将十进制的(15)转换为八进制的步骤如下：

1、 将商15除以8，商1余数为7；

2、将商1除以8，商0余数为1；

3、 读数，读数字从最后的余数向前读，17。
将十进制的(15)转换为十六进制的步骤如下：

1、 将商15除以16，商0余数为15；

2、读数，读数字从最后的余数向前读，15，十六进制用字母F表示。

 
&O11 '八进制的11 
&H9 '十六进制的9 

即在数值前加 &O、&H限定 表示八进制、十六进制数 
不加的话 默认为十进制的 

二进制好像没有 

HEX()函数是将数值转换成十六进制 
OCT()是。。。八进制 
转载于:https://www.cnblogs.com/darrenz/archive/2012/07/11/2585770.html

今天碰到一个这样的问题。我在修改以前用VB写的一个功能，这个功能中有一个部分是使用着色器给一段文字上色。然后这个颜色值存入数据库中的值是一个十进制数。新项目用C#，在Winform中需要读取这个数据给文字画上颜色。

 

通过上网找资料以及结合个人理解，该转换过程主要有以下几个步骤：

1、十进制数转成十六进制字符串。

2、十六进制字符串转成RGB码。

3、RGB码转成Color类型的值，给控件文字颜色属性赋值。

 

 

在研究这个功能实现的过程中需要先了解一些关键点。

首先，就是colorEdit等选颜色的控件都是通过设置RGB值来设置颜色的。而且R、G、B的范围都是0~255。转成十六进制就是0~FF。因此十六进制字符串为6位字符的字符串，范围为000000~FFFFFF。

其次，就是十进制转成十六进制字符串时，字符串的字符个数可能没有6位，这种情况需要在字符串前补0。如果超过6位，说明这个十进制不是用来转颜色码的。

最后，通过测试发现这个6位字符的十六进制字符串，前两个字符对应这RGB码的B位，中间两位对应G位，后面两位对应R位。

 

一、十进制转十六进制

/// <summary>
        /// 十进制转换到十六进制
        /// </summary>
        /// <param name="strDecimal">十进制数的字符串</param>
        /// <returns>十六进制字符串</returns>
        public static string Decimal2Hexadecimal(string strDecimal)
        {
            //十进制数
            ulong Decimal = Convert.ToUInt64(strDecimal);
            //十六的倍数
            ulong HexadecimalMultiple;
            //十六进制数取余16
            ulong HexadecimalChar;
            //十六进制字符串
            string Hexadecimal = "";
            do
            {
                HexadecimalMultiple = (ulong)Math.Floor((decimal)(Decimal / 16));
                HexadecimalChar = Decimal % 16;
                Hexadecimal = Number2Char(HexadecimalChar) + Hexadecimal;
                Decimal = HexadecimalMultiple;
            }
            while (Decimal >= 16);
            if (Decimal != 0)
                Hexadecimal = Number2Char(Decimal) + Hexadecimal;
            return Hexadecimal;
        }
        /// <summary>
        /// 数字转字符串
        /// </summary>
        /// <param name="number">数字</param>
        /// <returns>字符串</returns>
        public static string Number2Char(ulong number)
        {
            switch (number)
            {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                    return number.ToString();
                case 10:
                    return "A";
                case 11:
                    return "B";
                case 12:
                    return "C";
                case 13:
                    return "D";
                case 14:
                    return "E";
                case 15:
                    return "F";
                default:
                    return "";
            }
        }

二、十六进制转RGB编码以及转Color

        /// <summary>
        /// 十六进制转Color
        /// </summary>
        /// <param name="strHexadecimal">十六进制字符串</param>
        /// <returns>颜色值</returns>
        public static Color Hexadecimal2Color(string strHexadecimal)
        {
            try
            {
                if (strHexadecimal.Length == 0)
                {
                    return System.Drawing.Color.FromArgb(0, 0, 0);//设为黑色
                }
                else
                {
                    //十六进制颜色码为6个字符,补全6位字符
                    if (strHexadecimal.Length < 6)
                    {
                        strHexadecimal = strHexadecimal.PadLeft(6, '0');
                    }
                    string strB = strHexadecimal.Substring(0, 2);
                    string strG = strHexadecimal.Substring(2, 2);
                    string strR = strHexadecimal.Substring(4, 2);
                    int B = int.Parse(strB, System.Globalization.NumberStyles.AllowHexSpecifier);
                    int G = int.Parse(strG, System.Globalization.NumberStyles.AllowHexSpecifier);
                    int R = int.Parse(strR, System.Globalization.NumberStyles.AllowHexSpecifier);
                    //RGB转Color
                    Color color = Color.FromArgb(R, G, B);
                    return color;
                }
            }
            catch
            {
                //设为黑色
                return System.Drawing.Color.FromArgb(0, 0, 0);
            }
        }

三、封装了前面几个方法后面，就可以封装一个十进制转Color的方法了

        /// <summary>
        /// 十进制转Color
        /// </summary>
        /// <param name="Decimal">十进制数</param>
        /// <returns>颜色值</returns>
        public static Color Decimal2Color(string Decimal)
        {
           return Hexadecimal2Color(Decimal2Hexadecimal(Decimal));
        }

 

以上是没有考虑微软已经封装好的方法，自己去思考的步骤写出来的。接下来使用微软封装好的一些方法能够使代码更优。

private static Color Decimal2Color(ulong Decimal)
        {
            string Hexadecimal = Decimal.ToString("X6");
            string strB = Hexadecimal.Substring(0, 2);
            string strG = Hexadecimal.Substring(2, 2);
            string strR = Hexadecimal.Substring(4, 2);
            int B = Convert.ToInt32(strB, 16);
            int G = Convert.ToInt32(strG, 16);
            int R = Convert.ToInt32(strR, 16);
            return Color.FromArgb(R, G, B);
        }

ulong类型的十进制数字.ToString("X6");会转成十六进制的6位字符串，并且不足6位时会在原来基础的前面补0。

接下来就是拆分出R、G、B分别对应的字符。

接着，通过Convert.ToInt32("",16),能够把16进制字符转成R、G、B的32位整形数值。

最后使用Color对象的FromArgb()方法，对应放入R、G、B参数值就可以得出颜色。