字符串帮助类大全
如图（截图没截全，主要看代码）：代码：
#region UTF8转换
public static string ConvertUTF8(string strSource)
{
UTF8Encoding utf8 = new UTF8Encoding();
Byte[] encodedBytes = utf8.GetBytes(strSource);
string strDecoded = utf8.GetString(encodedBytes);
return strDecoded;
}
#endregion
#region 私有构成函数
private BasicStringHelper()
{ }
#endregion
#region 过滤Sql语句属性列字符串
/// <summary>
///
/// </summary>
/// <param name="intaItemIndex"></param>
/// <param name="strSql"></param>
/// <returns></returns>
public static string FilterTSql(int[] intaItemIndex, string strSql)
{
string strFilterResult = string.Empty;
if (intaItemIndex != null && strSql != null && intaItemIndex.Length > 0 && strSql.Length > 0)
{
string strPreFix = "select", strSuffix = "from";
string strItem = strSql.Substring(strSql.IndexOf(strPreFix) + strPreFix.Length, strSql.IndexOf(strSuffix) - strPreFix.Length);
string[] straItem = strItem.Split(',');
//strResult = straDataItem.ToString();
foreach (int ItemIndex in intaItemIndex)
{
if (ItemIndex <= straItem.Length)
{
strFilterResult += string.Format("{0},", straItem);
}
}
strFilterResult = strFilterResult.Substring(0, strFilterResult.LastIndexOf(',')).Trim();
strFilterResult = string.Format("{0} {1} {2}", strPreFix, strFilterResult, strSql.Substring(strSql.IndexOf(strSuffix)));
}
else
{
strFilterResult = strSql;
}
return strFilterResult;
}
/// <summary>
///
/// </summary>
/// <param name="intaItemIndex"></param>
/// <param name="strSql"></param>
/// <param name="strPreFix"></param>
/// <returns></returns>
public static string FilterTSql(int[] intaItemIndex, string strSql, string strPreFix)
{
string strFilterResult = string.Empty;
if (intaItemIndex != null && intaItemIndex.Length > 0 && strSql.Length > 0)
{
string strSuffix = "from";
string strItem = strSql.Substring(strSql.IndexOf(strPreFix) + strPreFix.Length, strSql.IndexOf(strSuffix) - strPreFix.Length);
string[] straItem = strItem.Split(',');
//strResult = straDataItem.ToString();
foreach (int ItemIndex in intaItemIndex)
{
if (ItemIndex <= straItem.Length)
{
strFilterResult += string.Format("{0},", straItem);
}
}
strFilterResult = strFilterResult.Substring(0, strFilterResult.LastIndexOf(','));
}
else
{
strFilterResult = strSql;
}
return strFilterResult;
}
#endregion
#region 字符串包含指定字符数量
/// <summary>
/// 得到字符串包含指定字符数量
/// </summary>
/// <param name="strOriginalstring">原始字符串</param>
/// <param name="strAssignString">指定字符串</param>
/// <returns>整型，自定字符数量</returns>
public static int GetAssignStringCount(string strOriginalstring, string strAssignString)
{
return Regex.Matches(strOriginalstring, strAssignString).Count;
}
#endregion
#region 验证是否为整数值
/// <summary>
/// 验证是否为整数值
/// </summary>
/// <param name="strRawData">待验证字符串</param>
/// <returns>布尔结果：true为整数，false为非整数值</returns>
public static bool CheckInteger(string strRawData)
{
bool checkSign = true;
for (int iCnt = 0; iCnt < strRawData.Length; iCnt++)
{
if (!char.IsDigit(strRawData))
{
checkSign = false;
iCnt = strRawData.Length;
}
}
return checkSign;
}
#endregion
#region 当前时间组合字符串
/// <summary>
/// 获取时间时间组合字符串
/// </summary>
/// <returns>时间组合字符串</returns>
public static string GetNowDateTimeString(string strPrefix)
{
DateTime dtNowTime = DateTime.Now;
return strPrefix + dtNowTime.Year.ToString() + (dtNowTime.Month.ToString().Length == 2 ? dtNowTime.Month.ToString() : ("0" + dtNowTime.Month.ToString())) + (dtNowTime.Day.ToString().Length == 2 ? dtNowTime.Day.ToString() : ("0" + dtNowTime.Day.ToString())) + (dtNowTime.Hour.ToString().Length == 2 ? dtNowTime.Hour.ToString() : ("0" + dtNowTime.Hour.ToString())) + (dtNowTime.Minute.ToString().Length == 2 ? dtNowTime.Minute.ToString() : ("0" + dtNowTime.Minute.ToString()));
}
#endregion
#region 日期格式化
/// <summary>
/// 使用指定的格式来格式化日期（使用例子：DateTimeToString(dtLastUpdate, BasicType.DateTimeFormater.dtfLongDateTime)）
/// </summary>
/// <param name="ADateTime">待转格式化的时间字符串</param>
/// <param name="AFormater">指定的格式类型</param>
/// <returns></returns>
public static string DateTimeToString(DateTime ADateTime, BasicType.DateTimeFormater AFormater)
{
string strResult = "";
if (AFormater != BasicType.DateTimeFormater.dtfTime)
strResult += ADateTime.Year.ToString("0000") + "-" + ADateTime.Month.ToString("00") + "-" + ADateTime.Day.ToString("00");
if (AFormater != BasicType.DateTimeFormater.dtfDate)
strResult += ADateTime.Hour.ToString("00") + ":" + ADateTime.Minute.ToString("00") + ":" + ADateTime.Second.ToString("00");
if (AFormater == BasicType.DateTimeFormater.dtfLongDateTime)
strResult += "." + ADateTime.Millisecond.ToString("000");
if (ADateTime == DateTime.MinValue)
return strResult.Trim().Replace("0001-01-01", "1900-01-01");
else
return strResult.Trim();
}
/// <summary>
/// 使用指定的格式来格式化日期（使用例子：DateTimeToString(dtLastUpdate, BasicType.DateTimeFormater.dtfLongDateTime)）
/// </summary>
/// <param name="ADateTime">待转格式化的时间字符串</param>
/// <param name="AFormater">指定的格式类型</param>
/// <returns></returns>
public static string DateTimeToString(BasicType.DateTimeFormater AFormater)
{
string strResult = "";
DateTime ADateTime = DateTime.Now;
if (AFormater != BasicType.DateTimeFormater.dtfTime)
strResult += ADateTime.Year.ToString("0000") + "-" + ADateTime.Month.ToString("00") + "-" + ADateTime.Day.ToString("00");
if (AFormater != BasicType.DateTimeFormater.dtfDate)
strResult += ADateTime.Hour.ToString("00") + ":" + ADateTime.Minute.ToString("00") + ":" + ADateTime.Second.ToString("00");
if (AFormater == BasicType.DateTimeFormater.dtfLongDateTime)
strResult += "." + ADateTime.Millisecond.ToString("000");
if (ADateTime == DateTime.MinValue)
return strResult.Trim().Replace("0001-01-01", "1900-01-01");
else
return strResult.Trim();
}
#endregion
#region 生成0-z随机字符串
/// <summary>
/// 获取0-z随即字符串
/// </summary>
/// <param name="stringLength">字符串长度</param>
/// <returns>随即字符串</returns>
public static string GetRandomNumberLetterString(int stringLength)
{
System.Text.StringBuilder strReturn = new System.Text.StringBuilder();
Random rd = new Random();
while (strReturn.Length < stringLength)
{
char c = Convert.ToChar(rd.Next((byte)'0', (byte)'z'));
if (char.IsDigit(c) || char.IsLower(c) || char.IsUpper(c))
{
strReturn.Append(c);
}
}
return strReturn.ToString().Trim();
}
#endregion
#region 生成中文字符串
/// <summary>
/// 获取指定长度中文字符串
/// </summary>
/// <param name="length">字符串长度</param>
/// <returns>中文字符串</returns>
public static string GetChineseString(int length)
{
Encoding edGB = Encoding.GetEncoding("gb2312");
object[] bytes = CreateString(length);
//根据汉字字节解码出中文汉字
string strChineseString = string.Empty;
for (int i = 0; i < length; i++)
{
strChineseString += edGB.GetString((byte[])Convert.ChangeType(bytes, typeof(byte[])));
}
return strChineseString;
}
private static object[] CreateString(int strlength)
{
//定义一个数组存储汉字编码的组成元素
string[] strArray = new string { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
Random rdObject = new Random();//定义一个随机数对象
object[] objBytes = new object;
for (int i = 0; i < strlength; i++)
{
//获取区位码第一位
int intAreaOne = rdObject.Next(11, 14);
string strAreaOne = strArray.Trim();
//获取区位码第二位并防止数据重复
rdObject = new Random(intAreaOne * unchecked((int)DateTime.Now.Ticks) + i);
int intAreaTwo;
if (intAreaOne == 13)
{
intAreaTwo = rdObject.Next(0, 7);
}
else
{
intAreaTwo = rdObject.Next(0, 16);
}
string strAreaTwo = strArray.Trim();
//获取区位码第三位
rdObject = new Random(intAreaTwo * unchecked((int)DateTime.Now.Ticks) + i);
int intAreaThree = rdObject.Next(10, 16);
string strAreaThree = strArray.Trim();
//获取区位码第四位
rdObject = new Random(intAreaThree * unchecked((int)DateTime.Now.Ticks) + i);
int intAreaFore;
if (intAreaThree == 10)
{
intAreaFore = rdObject.Next(1, 16);
}
else if (intAreaThree == 15)
{
intAreaFore = rdObject.Next(0, 15);
}
else
{
intAreaFore = rdObject.Next(0, 16);
}
string str4 = strArray.Trim();
//定义字节变量存储产生的随机汉字区位码
byte byte1 = Convert.ToByte(strAreaOne + strAreaTwo, 16);
byte byte2 = Convert.ToByte(strAreaThree + str4, 16);
byte[] stradd = new byte[] { byte1, byte2 };
//将产生的汉字字节放入数组
objBytes.SetValue(stradd, i);
}
return objBytes;
}
#endregion
#region 生成特定符号分隔的字符串
/// <summary>
/// 生成特定符号分隔的字符串
/// </summary>
/// <param name="strDString">待处理字符串</param>
/// <param name="strSign">分隔符</param>
/// <returns>特定符号分隔的字符串</returns>
public static string GetDivisionString(string strDString, string strSign)
{
string strResult = string.Empty;
for (int i = 0; i < strDString.Length - 2; i++)
{
strResult += strDString.Substring(i, 1) + ",";
}
strResult += strDString.Substring(strDString.Length - 1, 1);
return strResult;
}
#endregion
#region 字符串转默认整数
/// <summary>
/// 将字符串转换成带默认值整数
/// </summary>
/// <param name="AIntString">待转换字符串</param>
/// <param name="AIntDef">默认整数</param>
/// <returns>整数</returns>
public static int StringToIntDefault(string AIntString, int AIntDef)
{
try
{
return int.Parse(AIntString + "");
}
catch
{
return AIntDef;
}
}
#endregion
#region 字符串转默认浮点数
/// <summary>
/// 将字符串转换成带默认值浮点数
/// </summary>
/// <param name="AFloatString">待转换字符串</param>
/// <param name="AFloatDef">默认浮点数</param>
/// <returns>浮点数</returns>
public static float StringToFloatDefault(string AFloatString, float AFloatDef)
{
try
{
return float.Parse(AFloatString + "");
}
catch
{
return AFloatDef;
}
}
#endregion
#region 字符串转默认日期
/// <summary>
/// 将字符串转换成带默认值日期(使用例子： StringToDateTimeDef("2011-07-01 09:12:07", DateTime.MinValue))
/// </summary>
/// <param name="ADateTimeString">规正的时间字符串</param>
/// <param name="ADateTimeDef">默认日期</param>
/// <returns></returns>
public static DateTime StringToDateTimeDefault(string ADateTimeString, DateTime ADateTimeDef)
{
try
{
return DateTime.Parse(ADateTimeString + "");
}
catch
{
return ADateTimeDef;
}
}
#endregion
#region 生成GUID字符串 16位、19位、32位
/// <summary>
/// 生成GUID（32位）字符串
/// </summary>
/// <returns>GUID（32位）字符串</returns>
public static string GenerateGUIDString()
{
return Guid.NewGuid().ToString().ToUpper().Replace("-", "");
}
/// <summary>
/// 生成追加前缀“？-”的GUID（32位）字符串
/// </summary>
/// <param name="strTempType">GUID字符串前缀类型</param>
/// <returns>追加前缀的GUID（32位）字符串</returns>
public static string GenerateGUIDString(string strTempType)
{
return string.Format("{0}-{1}", strTempType, GenerateGUIDString());
}
/// <summary>
/// 生成GUID（16位）字符串
/// </summary>
/// <returns>GUID（16位）字符串</returns>
public static string GenerateGUIDTo16String()
{
long i = 1;
foreach (byte b in Guid.NewGuid().ToByteArray())
i *= ((int)b + 1);
return string.Format("{0:x}", i - DateTime.Now.Ticks);
}
/// <summary>
/// 生成追加前缀“？-”的GUID（16位）字符串
/// </summary>
/// <param name="strTempType">GUID字符串前缀类型</param>
/// <returns>追加前缀的GUID（16位）字符串</returns>
public static string GenerateGUIDTo16String(string strTempType)
{
return string.Format("{0}-{1}", strTempType, GenerateGUIDTo16String());
}
/// <summary>
/// 生成GUID（19位）的唯一字符串
/// </summary>
/// <returns>GUID（19位）字符串</returns>
public static string GenerateGUIDTo19String()
{
byte[] buffer = Guid.NewGuid().ToByteArray();
return BitConverter.ToInt64(buffer, 0).ToString();
}
/// <summary>
/// 生成追加前缀“？-”的GUID（19位）字符串
/// </summary>
/// <param name="strTempType">GUID字符串前缀类型</param>
/// <returns>追加前缀的GUID（19位）字符串</returns>
public static string GenerateGUIDTo19String(string strTempType)
{
return string.Format("{0}-{1}", strTempType, GenerateGUIDTo19String());
}
#endregion
#region 中英文字符串截取
/// <summary>
/// 截取中英文字符串为指定长度
/// </summary>
/// <param name="strOriginal">要截取的字符串</param>
/// <param name="intCutLength">截取长度</param>
/// <returns>返回截取后的字符串</returns>
public static string CutEnCnString(string strOriginal, int intCutLength)
{
Regex regCode = new Regex("[\u4e00-\u9fa5]+", RegexOptions.Compiled);
char[] chrString = strOriginal.ToCharArray();
StringBuilder sbString = new StringBuilder();
int nLength = 0;
bool isCut = false;
for (int i = 0; i < chrString.Length; i++)
{
if (regCode.IsMatch((chrString).ToString()))
{
sbString.Append(chrString);
nLength += 2;
}
else
{
sbString.Append(chrString);
nLength = nLength + 1;
}
if (nLength > intCutLength)
{
isCut = true;
break;
}
}
if (isCut)
return sbString.ToString() + "...";
else
return sbString.ToString();
}
public static string SubString(string strCode, int intLength, bool bitSign)
{
Regex regex = new Regex("[\u4e00-\u9fa5]+", RegexOptions.Compiled);
char[] stringChar = strCode.ToCharArray();
StringBuilder sb = new StringBuilder();
int nLength = 0;
bool bitCut = false;
for (int i = 0; i < stringChar.Length; i++)
{
if (regex.IsMatch((stringChar).ToString()))
{
sb.Append(stringChar);
nLength += 2;
}
else
{
sb.Append(stringChar);
nLength = nLength + 1;
}
if (nLength > intLength)
{
bitCut = true;
break;
}
}
if (bitCut && bitSign)
return sb.ToString() + "...";
else
return sb.ToString();
}
#endregion
#region 截取左侧字符串
/// <summary>
/// 截取左侧1位字符（默认截取一位）
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <returns>截取后字符串</returns>
public static string CutLeftString(string strRaw)
{
return CutLeftString(strRaw, 1);
}
/// <summary>
/// 截取指定长度字符串
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <param name="intLength">截取字符串长度</param>
/// <returns>截取后字符串</returns>
public static string CutLeftString(string strRaw, int intLength)
{
if (strRaw.Length < intLength)
{
intLength = strRaw.Length;
}
return strRaw.Substring(0, intLength);
}
#endregion
#region 截取右侧字符串
/// <summary>
/// 截取右侧1位字符串（默认截取一位）
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <returns>截取后字符串</returns>
public static string CutRightString(string strRaw)
{
return CutRightString(strRaw, 1);
}
/// <summary>
/// 截取右侧指定长度字符串
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <param name="intLength">指定长度</param>
/// <returns>截取后字符串</returns>
public static string CutRightString(string strRaw, int intLength)
{
if (strRaw.Length < intLength)
{
intLength = strRaw.Length;
}
return strRaw.Substring(strRaw.Length - intLength, intLength);
}
#endregion
#region 创建重复字符串
/// <summary>
/// 创建重复字符串
/// </summary>
/// <param name="strDuplicateElement">重复字符串元素</param>
/// <param name="intDuplicateCount">重复计次</param>
/// <returns>生成的重复字符串</returns>
public static string CreateDuplicateString(string strDuplicateElement, int intDuplicateCount)
{
StringBuilder sbDuplicate = new StringBuilder();
for (int intSign = 0; intSign < intDuplicateCount; intSign++)
{
sbDuplicate.Append(strDuplicateElement);
}
return sbDuplicate.ToString();
}
#endregion
#region 指定字符填充字符串左侧不足长度的位置
/// <summary>
/// 指定字符填充指定长度字符串左侧不足长度的位置(默认填充“0”)
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <param name="intLength">字符串长度</param>
/// <returns>填充后字符串</returns>
public static string FillLeftString(string strRaw, int intLength)
{
return FillLeftString(strRaw, intLength, "0");
}
/// <summary>
/// 指定字符填充指定长度字符串左侧不足长度的位置
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <param name="intLength">字符串长度</param>
/// <param name="strRawElement">指定填充字符（为一个字节元，大于一个将自动选择第一个字节元）</param>
/// <returns>填充后字符串</returns>
public static string FillLeftString(string strRaw, int intLength, string strRawElement)
{
string strFill = string.Empty;
if (strRawElement.Length > 1)
{
strRawElement = strRawElement.Substring(0, 1);
}
if (strRaw.Length >= intLength)
{
strFill = strRaw;
}
else
{
strFill = CreateDuplicateString(strRawElement, intLength - strRaw.Length) + strRaw;
}
return strFill;
}
#endregion
#region 指定字符填充字符串右侧不足长度的位置
/// <summary>
/// 指定字符填充指定长度字符串右侧不足长度的位置(默认填充“0”)
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <param name="intLength">字符串长度</param>
/// <returns>填充后字符串</returns>
public static string FillRightString(string strRaw, int intLength)
{
return FillRightString(strRaw, intLength, "0");
}
/// <summary>
/// 指定字符填充指定长度字符串右侧不足长度的位置
/// </summary>
/// <param name="strRaw">待处理字符串</param>
/// <param name="intLength">字符串长度</param>
/// <param name="strRawElement">指定填充字符（为一个字节元，大于一个将自动选择第一个字节元）</param>
/// <returns>填充后字符串</returns>
public static string FillRightString(string strRaw, int intLength, string strRawElement)
{
string strFill = string.Empty;
if (strRawElement.Length > 1)
{
strRawElement = strRawElement.Substring(0, 1);
}
if (strRaw.Length >= intLength)
{
strFill = strRaw;
}
else
{
strFill = strRaw + CreateDuplicateString(strRawElement, intLength - strRaw.Length);
}
return strFill;
}
#endregion
#region 个位阿拉伯数字转中文数字（零、一、二、……）
/// <summary>
/// 中文数字
/// </summary>
private static string[] strChineseArray = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
/// <summary>
/// 个位阿拉伯数字转中文数字（零、一、二、……）
/// </summary>
/// <param name="intRaw">一位阿拉伯数字（0-9）</param>
/// <returns>中文数字</returns>
public static string GetBitsNumberToChinese(int intRaw)
{
string strResultChinese = string.Empty;
int intCount = -1;
foreach (string strChinese in strChineseArray)
{
intCount++;
if (intCount == intRaw)
{
strResultChinese = strChinese;
break;
}
}
return strResultChinese;
}
/// <summary>
/// 个位阿拉伯数字转中文数字（零、一、二、……）
/// </summary>
/// <param name="strRaw">字符串类型一位阿拉伯数字（“0”-“9”）</param>
/// <returns>中文数字</returns>
public static string GetBitsNumberToChinese(string strRaw)
{
return GetBitsNumberToChinese(Convert.ToInt32(strRaw));
}
#endregion
#region 个位阿拉伯数字转中文大写（零、壹、贰、……）
/// <summary>
/// 中文大写
/// </summary>
private static string[] strChineseCapitalArray = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
/// <summary>
/// 个位阿拉伯数字转中文大写（零、壹、贰、……）
/// </summary>
/// <param name="intRaw">一位阿拉伯数字（0-9）</param>
/// <returns>中文大写</returns>
public static string GetBitsNumberToChineseCapital(int intRaw)
{
string strResultChineseCapital = string.Empty;
int intCount = -1;
foreach (string strChineseCapital in strChineseCapitalArray)
{
intCount++;
if (intCount == intRaw)
{
strResultChineseCapital = strChineseCapital;
break;
}
}
return strResultChineseCapital;
}
/// <summary>
/// 个位阿拉伯数字转中文大写（零、壹、贰、……）
/// </summary>
/// <param name="strRaw">字符串类型一位阿拉伯数字（“0”-“9”）</param>
/// <returns>中文大写</returns>
public static string GetBitsNumberToChineseCapital(string strRaw)
{
return GetBitsNumberToChineseCapital(Convert.ToInt32(strRaw));
}
#endregion
#region 取得每四位阿拉伯数字的中文数字（万、亿、兆、京、……）
/// <summary>
/// 每四位数的中文数字
/// </summary>
private static string[] strEveryFourDigitsChineseArray = { "", "万", "亿", "兆", "京", "垓", "秭", "穰", "沟", "涧", "正", "载", "极" };
/// <summary>
/// 取得每四位阿拉伯数字的中文数字（万、亿、兆、京、……）
/// </summary>
/// <param name="intAnyFourDigitsSign">第n（0-12）个四位数</param>
/// <returns></returns>
public static string GetEveryFourDigitsChinese(int intAnyFourDigitsSign)
{
string strEveryFourChinese = "∞";
int intCount = -1;
foreach (string strEveryFourDigitsChinese in strEveryFourDigitsChineseArray)
{
intCount++;
if (intCount == intAnyFourDigitsSign)
{
strEveryFourChinese = strEveryFourDigitsChinese;
break;
}
}
return strEveryFourChinese;
}
#endregion
#region 整数转中文数字（10050 => 一万零五十）
/// <summary>
/// 整数转中文数字（10050 => 一万零五十）
/// </summary>
/// <param name="intRawNumber">待处理整数(int)</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToChinese(int intRawNumber)
{
return GetNumberToChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文数字（10050 => 一万零五十）
/// </summary>
/// <param name="intRawNumber">待处理整数(Int64)</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToChinese(Int64 intRawNumber)
{
return GetNumberToChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文数字（10050 => 一万零五十）
/// </summary>
/// <param name="intRawNumber">待处理整数(UInt64)</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToChinese(UInt64 intRawNumber)
{
return GetNumberToChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数字符串转中文数字（10050 => 一万零五十）
/// </summary>
/// <param name="strRawNumber">待处理整数字符串</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToChinese(string strRawNumber)
{
int intRawLength = 0, intSign = 0, intAnyFourSign = -1;
string strChinese = string.Empty, strReturnChinese = string.Empty, strTempChinese = string.Empty;
//检测是否为整数
if (!CheckInteger(strRawNumber))
{
strRawNumber = "0";
}
intRawLength = strRawNumber.Length;
//strRawNumber归一化（四位为一个处理单位）
intSign = intRawLength % 4;
strRawNumber = CreateDuplicateString("0", 4 - intSign) + strRawNumber;
intRawLength = strRawNumber.Length;
for (int intFourSign = 0; intFourSign < intRawLength; intFourSign += 4)
{
intAnyFourSign++;
strChinese = string.Empty;
for (int intEverySign = 0; intEverySign < 4; intEverySign++)
{
int intBitsSign = intRawLength - intFourSign - intEverySign - 1;
strTempChinese = GetBitsNumberToChinese(strRawNumber.Substring(intBitsSign, 1));
if (string.Equals(strTempChinese, "零"))
{
if (!string.Equals(CutLeftString(strChinese, 1), "零") & !string.IsNullOrEmpty(CutLeftString(strChinese, 1)))
{
strChinese = strTempChinese + strChinese;
}
}
else
{
switch (intEverySign)
{
case 0:
strChinese = strTempChinese;
break;
case 1:
strChinese = string.Format("{0}十{1}", strTempChinese, strChinese);
break;
case 2:
strChinese = string.Format("{0}百{1}", strTempChinese, strChinese);
break;
case 3:
strChinese = string.Format("{0}千{1}", strTempChinese, strChinese);
break;
default:
strChinese = string.Format("{0}∞{1}", strTempChinese, strChinese);
break;
}
}
}
if (string.Equals(strChinese, "零") & !string.IsNullOrEmpty(CutLeftString(strReturnChinese, 1)) & !string.Equals(CutLeftString(strReturnChinese, 1), "零"))
{
strReturnChinese = string.Format("零{0}", strReturnChinese);
}
else
{
if (!string.IsNullOrEmpty(strChinese))
{
strReturnChinese = strChinese + GetEveryFourDigitsChinese(intAnyFourSign) + strReturnChinese;
}
}
}
if (string.IsNullOrEmpty(strReturnChinese))
{
strReturnChinese = "零";
}
else if (string.Equals(CutLeftString(strReturnChinese, 1), "零"))
{
strReturnChinese = strReturnChinese.Substring(1, strReturnChinese.Length - 1);
}
return strReturnChinese;
}
#endregion
#region 整数转中文数字（10050 => 一万零千零百五十零）
/// <summary>
/// 整数转中文数字（10050 => 一万零千零百五十零）
/// </summary>
/// <param name="intRawNumber">待处理整数(int)</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToFillChinese(int intRawNumber)
{
return GetNumberToFillChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文数字（10050 => 一万零千零百五十零）
/// </summary>
/// <param name="intRawNumber">待处理整数(Int64)</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToFillChinese(Int64 intRawNumber)
{
return GetNumberToFillChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文数字（10050 => 一万零千零百五十零）
/// </summary>
/// <param name="intRawNumber">待处理整数(UInt64)</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToFillChinese(UInt64 intRawNumber)
{
return GetNumberToFillChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数字符串转中文数字（10050 => 一万零千零百五十零）
/// </summary>
/// <param name="strRawNumber">待处理整数字符串</param>
/// <returns>中文数字字符串</returns>
public static string GetNumberToFillChinese(string strRawNumber)
{
int intRawLength = 0, intSign = 0, intAnyFourSign = -1;
string strChinese = string.Empty, strReturnChinese = string.Empty, strTempChinese = string.Empty;
//检测是否为整数
if (!CheckInteger(strRawNumber))
{
strRawNumber = "0";
}
intRawLength = strRawNumber.Length;
//strRawNumber归一化（四位为一个处理单位）
intSign = intRawLength % 4;
strRawNumber = CreateDuplicateString("0", 4 - intSign) + strRawNumber;
intRawLength = strRawNumber.Length;
for (int intFourSign = 0; intFourSign < intRawLength; intFourSign += 4)
{
intAnyFourSign++;
strChinese = string.Empty;
for (int intEverySign = 0; intEverySign < 4; intEverySign++)
{
int intBitsSign = intRawLength - intFourSign - intEverySign - 1;
strTempChinese = GetBitsNumberToChinese(strRawNumber.Substring(intBitsSign, 1));
switch (intEverySign)
{
case 0:
strChinese = strTempChinese;
break;
case 1:
strChinese = string.Format("{0}十{1}", strTempChinese, strChinese);
break;
case 2:
strChinese = string.Format("{0}百{1}", strTempChinese, strChinese);
break;
case 3:
strChinese = string.Format("{0}千{1}", strTempChinese, strChinese);
break;
default:
strChinese = string.Format("{0}∞{1}", strTempChinese, strChinese);
break;
}
}
if (!string.IsNullOrEmpty(strChinese))
{
strReturnChinese = strChinese + GetEveryFourDigitsChinese(intAnyFourSign) + strReturnChinese;
}
}
while (string.Equals(CutLeftString(strReturnChinese, 1), "零") & strReturnChinese.Length > 1)
{
if (string.Equals(CutLeftString(strReturnChinese, 1), "零"))
{
strReturnChinese = strReturnChinese.Substring(2, strReturnChinese.Length - 2);
}
}
return strReturnChinese;
}
#endregion
#region 整数转简体中文数字（10050 => 一零零五零）
/// <summary>
/// 整数转简体中文数字（10050 => 一零零五零）
/// </summary>
/// <param name="intRawNumber">待处理整数(int)</param>
/// <returns>中文数字字符串</returns>
public string GetNumberShortChinese(int intRawNumber)
{
return GetNumberShortChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转简体中文数字（10050 => 一零零五零）
/// </summary>
/// <param name="intRawNumber">待处理整数(Int64)</param>
/// <returns>中文数字字符串</returns>
public string GetNumberShortChinese(Int64 intRawNumber)
{
return GetNumberShortChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转简体中文数字（10050 => 一零零五零）
/// </summary>
/// <param name="intRawNumber">待处理整数(UInt64)</param>
/// <returns>中文数字字符串</returns>
public string GetNumberShortChinese(UInt64 intRawNumber)
{
return GetNumberShortChinese(intRawNumber.ToString());
}
/// <summary>
/// 整数转简体中文数字（10050 => 一零零五零）
/// </summary>
/// <param name="strRawNumber">待处理整数字符串</param>
/// <returns>中文数字字符串</returns>
public string GetNumberShortChinese(string strRawNumber)
{
string strShortChinese = string.Empty;
if (!CheckInteger(strRawNumber))
{
strRawNumber = "0";
}
int intRawLength = strRawNumber.Length;
for (int intSign = 0; intSign < intRawLength; intSign++)
{
strShortChinese += GetBitsNumberToChinese(strRawNumber.ToString());
}
return strShortChinese;
}
#endregion
#region 整数转中文大写数字（10050 => 壹万零伍拾）
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零伍拾）
/// </summary>
/// <param name="strRawNumber">待处理整数（int）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapital(int intRawNumber)
{
return GetNumberToChineseCapital(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零伍拾）
/// </summary>
/// <param name="strRawNumber">待处理整数（Int64）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapital(Int64 intRawNumber)
{
return GetNumberToChineseCapital(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零伍拾）
/// </summary>
/// <param name="strRawNumber">待处理整数（UInt64）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapital(UInt64 intRawNumber)
{
return GetNumberToChineseCapital(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零伍拾）
/// </summary>
/// <param name="strRawNumber">待处理整数字符串</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapital(string strRawNumber)
{
int intRawLength = 0, intSign = 0, intAnyFourSign = -1;
string strChineseCapital = string.Empty, strResultChineseCapital = string.Empty, strTempChinese = string.Empty;
//检测是否为整数
if (!CheckInteger(strRawNumber))
{
strRawNumber = "0";
}
intRawLength = strRawNumber.Length;
//strRawNumber归一化（四位为一个处理单位）
intSign = intRawLength % 4;
strRawNumber = CreateDuplicateString("0", 4 - intSign) + strRawNumber;
intRawLength = strRawNumber.Length;
for (int intFourSign = 0; intFourSign < intRawLength; intFourSign += 4)
{
intAnyFourSign++;
strChineseCapital = string.Empty;
for (int intEverySign = 0; intEverySign < 4; intEverySign++)
{
int intBitsSign = intRawLength - intFourSign - intEverySign - 1;
strTempChinese = GetBitsNumberToChineseCapital(strRawNumber.Substring(intBitsSign, 1));
if (string.Equals(strTempChinese, "零"))
{
if (!string.Equals(CutLeftString(strChineseCapital, 1), "零") & !string.IsNullOrEmpty(CutLeftString(strChineseCapital, 1)))
{
strChineseCapital = strTempChinese + strChineseCapital;
}
}
else
{
switch (intEverySign)
{
case 0:
strChineseCapital = strTempChinese;
break;
case 1:
strChineseCapital = string.Format("{0}拾{1}", strTempChinese, strChineseCapital);
break;
case 2:
strChineseCapital = string.Format("{0}佰{1}", strTempChinese, strChineseCapital);
break;
case 3:
strChineseCapital = string.Format("{0}仟{1}", strTempChinese, strChineseCapital);
break;
default:
strChineseCapital = string.Format("{0}{1}", strTempChinese, strChineseCapital);
break;
}
}
}
if (string.Equals(strChineseCapital, "零") & !string.IsNullOrEmpty(CutLeftString(strResultChineseCapital, 1)) & !string.Equals(CutLeftString(strResultChineseCapital, 1), "零"))
{
strResultChineseCapital = string.Format("零{0}", strResultChineseCapital);
}
else
{
if (!string.IsNullOrEmpty(strChineseCapital))
{
strResultChineseCapital = strChineseCapital + GetEveryFourDigitsChinese(intAnyFourSign) + strResultChineseCapital;
}
}
}
if (string.IsNullOrEmpty(strResultChineseCapital))
{
strResultChineseCapital = "零";
}
else if (string.Equals(CutLeftString(strResultChineseCapital, 1), "零"))
{
strResultChineseCapital = strResultChineseCapital.Substring(1, strResultChineseCapital.Length - 1);
}
return strResultChineseCapital;
}
#endregion
#region 整数转中文大写数字（10050 => 壹万零仟零佰伍拾零）
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零仟零佰伍拾零）
/// </summary>
/// <param name="strRawNumber">待处理整数（int）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalFill(int intRawNumber)
{
return GetNumberToChineseCapitalFill(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零仟零佰伍拾零）
/// </summary>
/// <param name="strRawNumber">待处理整数（Int64）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalFill(Int64 intRawNumber)
{
return GetNumberToChineseCapitalFill(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零仟零佰伍拾零）
/// </summary>
/// <param name="strRawNumber">待处理整数（UInt64）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalFill(UInt64 intRawNumber)
{
return GetNumberToChineseCapitalFill(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹万零仟零佰伍拾零）
/// </summary>
/// <param name="strRawNumber">待处理整数字符串</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalFill(string strRawNumber)
{
int intRawLength = 0, intSign = 0, intAnyFourSign = -1;
string strChinese = string.Empty, strResultChineseCapitalFill = string.Empty, strTempChinese = string.Empty;
//检测是否为整数
if (!CheckInteger(strRawNumber))
{
strRawNumber = "0";
}
intRawLength = strRawNumber.Length;
//strRawNumber归一化（四位为一个处理单位）
intSign = intRawLength % 4;
strRawNumber = CreateDuplicateString("0", 4 - intSign) + strRawNumber;
intRawLength = strRawNumber.Length;
for (int intFourSign = 0; intFourSign < intRawLength; intFourSign += 4)
{
intAnyFourSign++;
strChinese = string.Empty;
for (int intEverySign = 0; intEverySign < 4; intEverySign++)
{
int intBitsSign = intRawLength - intFourSign - intEverySign - 1;
strTempChinese = GetBitsNumberToChineseCapital(strRawNumber.Substring(intBitsSign, 1));
switch (intEverySign)
{
case 0:
strChinese = strTempChinese;
break;
case 1:
strChinese = string.Format("{0}拾{1}", strTempChinese, strChinese);
break;
case 2:
strChinese = string.Format("{0}佰{1}", strTempChinese, strChinese);
break;
case 3:
strChinese = string.Format("{0}仟{1}", strTempChinese, strChinese);
break;
default:
strChinese = string.Format("{0}{1}", strTempChinese, strChinese);
break;
}
}
if (!string.IsNullOrEmpty(strChinese))
{
strResultChineseCapitalFill = strChinese + GetEveryFourDigitsChinese(intAnyFourSign) + strResultChineseCapitalFill;
}
}
while (string.Equals(CutLeftString(strResultChineseCapitalFill, 1), "零") & strResultChineseCapitalFill.Length > 1)
{
if (string.Equals(CutLeftString(strResultChineseCapitalFill, 1), "零"))
{
strResultChineseCapitalFill = strResultChineseCapitalFill.Substring(2, strResultChineseCapitalFill.Length - 2);
}
}
return strResultChineseCapitalFill;
}
#endregion
#region 整数转中文大写数字（10050 => 壹零零伍零）
/// <summary>
/// 整数转中文大写数字（10050 => 壹零零伍零）
/// </summary>
/// <param name="strRawNumber">待处理整数（int）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalShort(int intRawNumber)
{
return GetNumberToChineseCapitalShort(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹零零伍零）
/// </summary>
/// <param name="strRawNumber">待处理整数（Int64）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalShort(Int64 intRawNumber)
{
return GetNumberToChineseCapitalShort(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹零零伍零）
/// </summary>
/// <param name="strRawNumber">待处理整数（UInt64）</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalShort(UInt64 intRawNumber)
{
return GetNumberToChineseCapitalShort(intRawNumber.ToString());
}
/// <summary>
/// 整数转中文大写数字（10050 => 壹零零伍零）
/// </summary>
/// <param name="strRawNumber">待处理整数字符串</param>
/// <returns>中文数字大写字符串</returns>
public string GetNumberToChineseCapitalShort(string strRawNumber)
{
string strChineseCapitalShort = string.Empty;
if (!CheckInteger(strRawNumber))
{
strRawNumber = "0";
}
int intRawLength = strRawNumber.Length;
for (int intSign = 0; intSign < intRawLength; intSign++)
{
strChineseCapitalShort += GetBitsNumberToChineseCapital(strRawNumber.ToString());
}
return strChineseCapitalShort;
}
#endregion
312231
页:
[1]