C# 进制之间的转换
/// 十进制转换为二进制
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static string DecToBin(string x)
{
string z = null;
int X = Convert.ToInt32(x);
int i = 0;
long a, b = 0;
while (X > 0)
{
a = X%2;
X = X/2;
b = b + a*Pow(10, i);
i++;
}
z = Convert.ToString(b);
return z;
}
/// <summary>
/// 16进制转ASCII码
/// </summary>
/// <param name="hexString"></param>
/// <returns></returns>
public static string HexToAscii(string hexString)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i <= hexString.Length - 2; i += 2)
{
sb.Append(
Convert.ToString(
Convert.ToChar(Int32.Parse(hexString.Substring(i, 2),
System.Globalization.NumberStyles.HexNumber))));
}
return sb.ToString();
}
/// <summary>
/// 十进制转换为八进制
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static string DecToOtc(string x)
{
string z = null;
int X = Convert.ToInt32(x);
int i = 0;
long a, b = 0;
while (X > 0)
{
a = X%8;
X = X/8;
b = b + a*Pow(10, i);
i++;
}
z = Convert.ToString(b);
return z;
}
/// <summary>
/// 十进制转换为十六进制
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static string DecToHex(string x)
{
if (string.IsNullOrEmpty(x))
{
return "0";
}
string z = null;
int X = Convert.ToInt32(x);
Stack a = new Stack();
int i = 0;
while (X > 0)
{
a.Push(Convert.ToString(X%16));
X = X/16;
i++;
}
while (a.Count != 0)
z += ToHex(Convert.ToString(a.Pop()));
if (string.IsNullOrEmpty(z))
{
z = "0";
}
return z;
}
/// <summary>
/// 二进制转换为十进制
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static string BinToDec(string x)
{
string z = null;
int X = Convert.ToInt32(x);
int i = 0;
long a, b = 0;
while (X > 0)
{
a = X%10;
X = X/10;
b = b + a*Pow(2, i);
i++;
}
z = Convert.ToString(b);
return z;
}
/// <summary>
/// 二进制转换为十进制，定长转换
/// </summary>
/// <param name="x"></param>
/// <param name="iLength"></param>
/// <returns></returns>
public static string BinToDec(string x, short iLength)
{
StringBuilder sb = new StringBuilder();
int iCount = 0;
iCount = x.Length/iLength;
if (x.Length%iLength > 0)
{
iCount += 1;
}
int X = 0;
for (int i = 0; i < iCount; i++)
{
if ((i + 1)*iLength > x.Length)
{
X = Convert.ToInt32(x.Substring(i*iLength, (x.Length - iLength)));
}
else
{
X = Convert.ToInt32(x.Substring(i*iLength, iLength));
}
int j = 0;
long a, b = 0;
while (X > 0)
{
a = X%10;
X = X/10;
b = b + a*Pow(2, j);
j++;
}
sb.AppendFormat("{0:D2}", b);
}
return sb.ToString();
}
/// <summary>
/// 二进制转换为十六进制，定长转换
/// </summary>
/// <param name="x"></param>
/// <param name="iLength"></param>
/// <returns></returns>
public static string BinToHex(string x, short iLength)
{
StringBuilder sb = new StringBuilder();
int iCount = 0;
iCount = x.Length/iLength;
if (x.Length%iLength > 0)
{
iCount += 1;
}
int X = 0;
for (int i = 0; i < iCount; i++)
{
if ((i + 1)*iLength > x.Length)
{
X = Convert.ToInt32(x.Substring(i*iLength, (x.Length - iLength)));
}
else
{
X = Convert.ToInt32(x.Substring(i*iLength, iLength));
}
int j = 0;
long a, b = 0;
while (X > 0)
{
a = X%10;
X = X/10;
b = b + a*Pow(2, j);
j++;
}
//前补0
sb.Append(DecToHex(b.ToString()));
}
return sb.ToString();
}
/// <summary>
/// 八进制转换为十进制
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static string OctToDec(string x)
{
string z = null;
int X = Convert.ToInt32(x);
int i = 0;
long a, b = 0;
while (X > 0)
{
a = X%10;
X = X/10;
b = b + a*Pow(8, i);
i++;
}
z = Convert.ToString(b);
return z;
}
/// <summary>
/// 十六进制转换为十进制
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static string HexToDec(string x)
{
if (string.IsNullOrEmpty(x))
{
return "0";
}
string z = null;
Stack a = new Stack();
int i = 0, j = 0, l = x.Length;
long Tong = 0;
while (i < l)
{
a.Push(ToDec(Convert.ToString(x[i])));
i++;
}
while (a.Count != 0)
{
Tong = Tong + Convert.ToInt64(a.Pop())*Pow(16, j);
j++;
}
z = Convert.ToString(Tong);
return z;
}
#endregion //Helperfunctions
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
private static long Pow(long x, long y)
{
int i = 1;
long X = x;
if (y == 0)
return 1;
while (i < y)
{
x = x*X;
i++;
}
return x;
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
private static string ToDec(string x)
{
switch (x)
{
case "A":
return "10";
case "B":
return "11";
case "C":
return "12";
case "D":
return "13";
case "E":
return "14";
case "F":
return "15";
default:
return x;
}
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
private static string ToHex(string x)
{
switch (x)
{
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 x;
}
}
/// <summary>
/// 将16进制BYTE数组转换成16进制字符串
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
public static string ToHexString(byte[] bytes) // 0xae00cf => "AE00CF "
{
string hexString = string.Empty;
if (bytes != null)
{
StringBuilder strB = new StringBuilder();
for (int i = 0; i < bytes.Length; i++)
{
strB.Append(bytes[i].ToString("X2"));
}
hexString = strB.ToString();
}
return hexString;
}
///
/// </summary>
/// <param name="bytes"></param>
/// <param name="iLength"></param>
/// <returns></returns>
public static string ToHexString(byte[] bytes, int iLength) // 0xae00cf => "AE00CF "
{
string hexString = string.Empty;
if (bytes != null)
{
StringBuilder strB = new StringBuilder();
if (bytes.Length < iLength)
{
iLength = bytes.Length;
}
for (int i = 0; i < iLength; i++)
{
strB.Append(bytes[i].ToString("X2"));
}
hexString = strB.ToString();
}
return hexString;
}
/// <summary>
/// 将byte数组转换为16进制字符串
/// </summary>
/// <param name="bytes">要转换的数组</param>
/// <param name="iStart">数组下标</param>
/// <param name="iLength">长度</param>
/// <returns></returns>
public static string ToHexString(byte[] bytes, int iStart, int iLength) // 0xae00cf => "AE00CF "
{
string hexString = string.Empty;
if (bytes != null)
{
StringBuilder strB = new StringBuilder();
//缓冲区长度问题，需清空缓冲区
if (bytes.Length < (iLength + iStart))
{
iLength = bytes.Length;
}
for (int i = iStart; i < iLength + iStart; i++)
{
strB.Append(bytes[i].ToString("X2"));
}
hexString = strB.ToString();
}
return hexString;
}
/// <summary>
///
/// </summary>
/// <param name="hexString"></param>
/// <param name="discarded"></param>
/// <returns></returns>
public static byte[] GetBytes(string hexString, out int discarded)
{
discarded = 0;
string newString = "";
char c;
// remove all none A-F, 0-9, characters
for (int i = 0; i < hexString.Length; i++)
{
c = hexString[i];
if (Uri.IsHexDigit(c))
newString += c;
else
discarded++;
}
// if odd number of characters, discard last character
if (newString.Length%2 != 0)
{
discarded++;
newString = newString.Substring(0, newString.Length - 1);
}
return HexToByte(newString);
}
/// <summary>
/// Converts from binary coded decimal to integer
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public static uint BcdToDec(uint num)
{
return HornerScheme(num, 0x10, 10);
}
/// <summary>
/// Converts from integer to binary coded decimal
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public static uint DecToBcd(uint num)
{
return HornerScheme(num, 10, 0x10);
}
private static uint HornerScheme(uint num, uint divider, uint factor)
{
uint remainder = 0, quotient = 0, result = 0;
remainder = num%divider;
quotient = num/divider;
if (!(quotient == 0 && remainder == 0))
result += HornerScheme(quotient, divider, factor)*factor + remainder;
return result;
}
/// <summary>
/// byte数组尾部0截取函数
/// </summary>
/// <param name="buf">原始byte数组</param>
/// <param name="iLength">要截取的长度</param>
/// <returns>截取后的数组</returns>
public static byte[] InterceptByte(byte[] buf, int iLength)
{
StringBuilder sb = new StringBuilder(iLength*2);
sb = sb.Append(ToHexString(buf, (short) iLength));
int discarded = 0;
byte[] bReturn = GetBytes(sb.ToString(), out discarded);
if (discarded > 0)
{
throw new Exception("byte数组截取有数据丢失！");
}
return bReturn;
}
/// <summary>
///
/// </summary>
/// <param name="hexString"></param>
/// <returns></returns>
public static byte[] HexToByte(string hexString)
{
if (string.IsNullOrEmpty(hexString))
{
hexString = "00";
}
byte[] returnBytes = new byte[hexString.Length/2];
for (int i = 0; i < returnBytes.Length; i++)
returnBytes[i] = Convert.ToByte(hexString.Substring(i*2, 2), 16);
return returnBytes;
}
/// <summary>
/// 日期转BCD数组
/// </summary>
/// <param name="dateTime"></param>
/// <param name="type">4 6 7</param>
/// <returns></returns>
public static byte[] DateTimeToBCD(DateTime dateTime, ushort type)
{
string strServerTime = string.Format("{0:yyyyMMddHHmmss}", dateTime);
byte[] bcd = new byte[type];
if (type == 4)
{
bcd[0] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(0, 2))).ToString("D2"));
bcd[1] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(2, 2))).ToString("D2"));
bcd[2] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(4, 2))).ToString("D2"));
bcd[3] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(6, 2))).ToString("D2"));
}
if (type == 6)
{
bcd[0] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(2, 2))).ToString("D2"));
bcd[1] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(4, 2))).ToString("D2"));
bcd[2] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(6, 2))).ToString("D2"));
bcd[3] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(8, 2))).ToString("D2"));
bcd[4] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(10, 2))).ToString("D2"));
bcd[5] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(12, 2))).ToString("D2"));
}
if (type == 7)
{
bcd[0] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(0, 2))).ToString("D2"));
bcd[1] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(2, 2))).ToString("D2"));
bcd[2] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(4, 2))).ToString("D2"));
bcd[3] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(6, 2))).ToString("D2"));
bcd[4] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(8, 2))).ToString("D2"));
bcd[5] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(10, 2))).ToString("D2"));
bcd[5] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(12, 2))).ToString("D2"));
}
return bcd;
}
/// <summary>
/// BCD时间转日期时间
/// </summary>
/// <param name="bcdTime"></param>
/// <param name="type"></param>
/// <returns></returns>
public static DateTime BCDToDateTime(byte[] bcdTime, ushort type)
{
StringBuilder sb = new StringBuilder();
if (type == 4) //4位BCD码的日期
{
sb.Append(BcdToDec(bcdTime[0]).ToString("D2"));
sb.Append(BcdToDec(bcdTime[1]).ToString("D2"));
sb.Append('-' + BcdToDec(bcdTime[2]).ToString("D2"));
sb.Append('-' + BcdToDec(bcdTime[3]).ToString("D2") + " ");
}
if (type == 6) //6位BCD码的时间
{
sb.Append(DateTime.Now.ToString("yyyy").Substring(0, 2));
sb.Append(BcdToDec(bcdTime[0]).ToString("D2"));
sb.Append('-' + BcdToDec(bcdTime[1]).ToString("D2"));
sb.Append('-' + BcdToDec(bcdTime[2]).ToString("D2") + " ");
sb.Append(BcdToDec(bcdTime[3]).ToString("D2") + ":");
sb.Append(BcdToDec(bcdTime[4]).ToString("D2") + ":");
sb.Append(BcdToDec(bcdTime[5]));
}
if (type == 7) //7位BCD码的日期
{
sb.Append(BcdToDec(bcdTime[0]).ToString("D2"));
sb.Append(BcdToDec(bcdTime[1]).ToString("D2"));
sb.Append('-' + BcdToDec(bcdTime[2]).ToString("D2"));
sb.Append('-' + BcdToDec(bcdTime[3]).ToString("D2") + " ");
sb.Append(BcdToDec(bcdTime[4]).ToString("D2") + ":");
sb.Append(BcdToDec(bcdTime[5]).ToString("D2") + ":");
sb.Append(BcdToDec(bcdTime[6]));
}
DateTime dt;
//2011-3-26 当日期出错时的处理
DateTime.TryParse(sb.ToString(), out dt);
return dt;
}
}
}
C# 进制之间的转换相关推荐
- java中各进制之间的转换(十进制转十六进制、十进制转二进制、二进制转十进制、二进制转十六进制)...
在java编辑中有没有遇到经常需要进行java中各进制之间的转换(十进制转十六进制.十进制转二进制.二进制转十进制.二进制转十六进制)的事情呢?下面我们就来分析一下各自是怎么转换的: [java] / ...
- 二进制-八进制-十进制-16进制之间的转换
进制之间的转换 主要用到连个函数: Convert.ToInt32(str,numbased):将字符串转成str,按照numbeased指定的进制转成10进制数: Convert.ToString( ...
- JAVA进制及进制之间的转换
进制 一.进制 二进制: 0.1 满二进一 以0b开头作为标识 在jdk1.7之前程序中无法直接书写一个二进制数字 八进制: 0~7,满8进1 要求以0做开头为标识 十进制 十六进制: 0~9.A~F ...
- 9277用计算机,关于计算机常用进制以及进制之间的转换笔记
计算机常用进制以及进制之间的转换 进制的由来 生活中的常用进制 计算机中的二进制 计算机常用四种进制的说明 八进制和十六进制 进制之间的转换 进制的由来 进位就是进位计数制,就是一种计数的方法 古代社 ...
- c 语言转换成php语言,C++_C 语言进制之间的转换，二进制、八进制和十六进制向 - phpStudy...
C 语言进制之间的转换 二进制.八进制和十六进制向十进制转换都是非常容易的,就是"按权相加". 所谓"权",也即"位权".例如,十进制第1位 ...
- 一篇关于不同进制之间的转换、比如二进制、八进制、十进制、十六进制等
1.其他进制转十进制二进制转十进制计算公式:从最低位开始(右边起),将每个位上的数提取出来,乘于2的(位数-1)次方,然后求和1101 =1*2^0+0*2^1+1*2^2+1*2^3=1+0+4+8 ...
- 计算机中各进制之间的转换
各进制之间的转换 由于有些时候总是会忘记一些各种进制之间的转换,长时间不用,就会比较模糊,所有就将其做个总结. 二进制转十进制 首先就相当于二进制数 个位数x20+十位数x21+百位数x22- 例子 ...
- Python中各种进制之间的转换
Python整数能够以十六进制,八进制和二进制来编写,作为一般以10位基数的十进制计数法的补充. 一: 上面三种进制的常用表示 >>> 0o1, 0o20, 0o377 # 八进制常 ...
- C++控制不同进制输出（二进制，八进制，十进制，十六进制）各种进制之间的转换
目录 1.输出(头文件讲解) 2.格式控制 常用的I/O流控制符 4.各种进制之间的转换(进制大乱斗) 4.1.写在前面 4.2整体框架搭建 4.3菜单函数 4.4用户输入选择(main函数体中) 4 ...
- 一.关于进制之间的转换关系
一.关于进制之间的转换关系 我们所说的百兆,千兆网络单位是bps(比特率,位/秒/bit/s),通常所说的百兆光纤也就是100Mps,而在实际应用中使用的传输单位是字节/秒(byte/s). 8bit ...
最新文章
- RedHat Enterprise Linux 5.0之LVM逻辑卷管理
- 【干货】裸金属服务Ironic项目介绍
- python 压缩图片
- 欢迎使用CSDN-markdown编辑器7-3
- 构建器设计模式_创新设计模式：构建器模式
- Svcutil.exe详解
- 12001.linux应用程序之i2c编程
- 树莓派 烧录arm64架构centos7
- java中单，单|的意思，按位操作符详述
- 导入项目jsp文件报错，但打开相应的文件并没有错误解决办法
- TYVJ 4354 多重背包二进制优化
- MySql数据库基本语句
- Delphi程序破解技术概要
- vant/vue获取商品筛选分类接口以及替换原有的键名
- Python模拟随机游走
- Python 编程之Tkinter的使用01
- sql日志的详细打印的配置
- Python爬虫批量下载文献
- APS实现的要点与难点
- 什么是脏读、幻读、不可重复读?要怎么处理?