常用类型转换

 

 using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Data;
using  System.Collections;
using  Microsoft.VisualBasic;

namespace  Thewolfs.Framework.Text
{
     ///   <summary>
     ///  类型转换类
     ///   </summary>
     public   class  TwConvert
    {
         #region  将数字金额转换成大写人民币形式。
         ///   <summary>
         ///  将数字金额转换成大写人民币形式。
         ///   </summary>
         ///   <param name="num"> 金额 </param>
         ///   <returns> 返回大写形式 </returns>
         public   static   string  Num2RMB( decimal  num)
        {
             string  _chineseNumbers  =   " 零壹贰叁肆伍陆柒捌玖 " ;  // 0-9所对应的汉字
             string  _chineseUnits  =   " 万仟佰拾亿仟佰拾万仟佰拾元角分 " ;  // 数字位所对应的汉字
             string  _sourceNumItem  =   "" ;  // 从原num值中取出的值
             string  _chineseNumItem  =   "" ;  // 数字的字符串形式
             string  _chineseUnitItem  =   "" ;  // 人民币大写金额形式
             int  i;  // 循环变量
             int  j;  // num的值乘以100的字符串长度
             string  _chineseNumberSpell  =   "" ;  // 数字的汉语读法
             string  _chineseUnitSpell  =   "" ;  // 数字位的汉字读法
             int  _continuousZeroCount  =   0 ;  // 用来计算连续的零值是几个
             int  _tempNumber;  // 从原num值中取出的值

            num  =  Math.Round(Math.Abs(num),  2 );  // 将num取绝对值并四舍五入取2位小数
            _chineseNumItem  =  (( long )(num  *   100 )).ToString();  // 将num乘100并转换成字符串形式
            j  =  _chineseNumItem.Length;  // 找出最高位
             if  (j  >   15 )
            {
                 return   " 溢出 " ;
            }
            _chineseUnits  =  _chineseUnits.Substring( 15   -  j);  // 取出对应位数的str2的值。如：200.55,j为5所以str2=佰拾元角分

             // 循环取出每一位需要转换的值
             for  (i  =   0 ; i  <  j; i ++ )
            {
                _sourceNumItem  =  _chineseNumItem.Substring(i,  1 );  // 取出需转换的某一位的值
                _tempNumber  =  Convert.ToInt32(_sourceNumItem);  // 转换为数字
                 if  (i  !=  (j  -   3 )  &&  i  !=  (j  -   7 )  &&  i  !=  (j  -   11 )  &&  i  !=  (j  -   15 ))
                {
                     // 当所取位数不为元、万、亿、万亿上的数字时
                     if  (_sourceNumItem  ==   " 0 " )
                    {
                        _chineseNumberSpell  =   "" ;
                        _chineseUnitSpell  =   "" ;
                        _continuousZeroCount  =  _continuousZeroCount  +   1 ;
                    }
                     else
                    {
                         if  (_sourceNumItem  !=   " 0 "   &&  _continuousZeroCount  !=   0 )
                        {
                            _chineseNumberSpell  =   " 零 "   +  _chineseNumbers.Substring(_tempNumber  *   1 ,  1 );
                            _chineseUnitSpell  =  _chineseUnits.Substring(i,  1 );
                            _continuousZeroCount  =   0 ;
                        }
                         else
                        {
                            _chineseNumberSpell  =  _chineseNumbers.Substring(_tempNumber  *   1 ,  1 );
                            _chineseUnitSpell  =  _chineseUnits.Substring(i,  1 );
                            _continuousZeroCount  =   0 ;
                        }
                    }
                }
                 else
                {
                     // 该位是万亿，亿，万，元位等关键位
                     if  (_sourceNumItem  !=   " 0 "   &&  _continuousZeroCount  !=   0 )
                    {
                        _chineseNumberSpell  =   " 零 "   +  _chineseNumbers.Substring(_tempNumber  *   1 ,  1 );
                        _chineseUnitSpell  =  _chineseUnits.Substring(i,  1 );
                        _continuousZeroCount  =   0 ;
                    }
                     else
                    {
                         if  (_sourceNumItem  !=   " 0 "   &&  _continuousZeroCount  ==   0 )
                        {
                            _chineseNumberSpell  =  _chineseNumbers.Substring(_tempNumber  *   1 ,  1 );
                            _chineseUnitSpell  =  _chineseUnits.Substring(i,  1 );
                            _continuousZeroCount  =   0 ;
                        }
                         else
                        {
                             if  (_sourceNumItem  ==   " 0 "   &&  _continuousZeroCount  >=   3 )
                            {
                                _chineseNumberSpell  =   "" ;
                                _chineseUnitSpell  =   "" ;
                                _continuousZeroCount  =  _continuousZeroCount  +   1 ;
                            }
                             else
                            {
                                 if  (j  >=   11 )
                                {
                                    _chineseNumberSpell  =   "" ;
                                    _continuousZeroCount  =  _continuousZeroCount  +   1 ;
                                }
                                 else
                                {
                                    _chineseNumberSpell  =   "" ;
                                    _chineseUnitSpell  =  _chineseUnits.Substring(i,  1 );
                                    _continuousZeroCount  =  _continuousZeroCount  +   1 ;
                                }
                            }
                        }
                    }
                }
                 if  (i  ==  (j  -   11 )  ||  i  ==  (j  -   3 ))
                {
                     // 如果该位是亿位或元位，则必须写上
                    _chineseUnitSpell  =  _chineseUnits.Substring(i,  1 );
                }
                _chineseUnitItem  =  _chineseUnitItem  +  _chineseNumberSpell  +  _chineseUnitSpell;

                 if  (i  ==  j  -   1   &&  _sourceNumItem  ==   " 0 " )
                {
                     // 最后一位（分）为0时，加上“整”
                    _chineseUnitItem  =  _chineseUnitItem  +   ' 整 ' ;
                }
            }
             if  (num  ==   0 )
            {
                _chineseUnitItem  =   " 零元整 " ;
            }
             return  _chineseUnitItem;
        }

         ///   <summary>
         ///  将数字金额转换成大写人民币形式。
         ///  一个重载，将字符串先转换成数字在调用CmycurD(decimal num)
         ///   </summary>
         ///   <param name="numstr"> 用户输入的金额，字符串形式未转成decimal </param>
         ///   <returns></returns>
         public   static   string  Num2RMB( string  numstr)
        {
             try
            {
                 decimal  num  =  Convert.ToDecimal(numstr);
                 return  Num2RMB(num);
            }
             catch
            {
                 return   " 非数字形式！ " ;
            }
        }
         #endregion

         #region  GB2312转换成UTF-8
         ///   <summary>
         ///  将GB2312转换成UTF-8
         ///   </summary>
         ///   <param name="s"></param>
         ///   <returns></returns>
         public   static   string  GB2312ToUTF8( string  content)
        {
             byte [] _byteData  =  Encoding.Default.GetBytes(content);
            String _content  =  Encoding.UTF8.GetString(_byteData);
             return  _content;
        }
         #endregion

         #region  类型转换

         #region  Boolean类型转换
         ///   <summary>
         ///  转换成Boolean类型
         ///   </summary>
         ///   <param name="value"> 值可以是 true false 或者 1 0 </param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   bool  ToBoolean( object  value,  bool  defaultValue)
        {
             if  (value  ==   null )
            {
                 return  defaultValue;
            }
             string  _value  =  value.ToString().ToLower();
             if  (_value  ==   " true "   ||  _value  ==   " 1 "   ||  _value  ==   " -1 " )
            {
                 return   true ;
            }
             if  (_value  ==   " false "   ||  _value  ==   " 0 " )
            {
                 return   false ;
            }

             return  defaultValue;
        }

         ///   <summary>
         ///  转换成Boolean类型,[默认值 = False]
         ///   </summary>
         ///   <param name="value"> 值可以是 true false 或者 1 0 </param>
         ///   <returns></returns>
         public   static   bool  ToBoolean( object  value)
        {
             return  ToBoolean(value,  false );
        }
         #endregion

         #region  Char类型转换
         ///   <summary>
         ///  转换成Char类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   char  ToChar( object  value,  char  defaultValue)
        {
             try
            {
                 char  _value  =  Convert.ToChar(value);
                 return  _value;
            }
             catch
            {
                 return  defaultValue;
            }
        }
         #endregion

         #region  DateTime类型转换
         ///   <summary>
         ///  转换成 DateTime 类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static  System.DateTime ToDateTime( object  value, System.DateTime defaultValue)
        {
             try
            {
                 return  Convert.ToDateTime(value);
            }
             catch
            {
                 return  defaultValue;
            }
        }

         ///   <summary>
         ///  转换成 DateTime 类型 [默认值 = DateTime.Now]
         ///   </summary>
         ///   <param name="value"></param>
         ///   <returns></returns>
         public   static  System.DateTime ToDateTime( object  value)
        {
             return  ToDateTime(value, DateTime.Now);
        }
         #endregion


         #region  Decimal类型转换
         ///   <summary>
         ///  转换成 Decimal 类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   decimal  ToDecimal( object  value, Decimal defaultValue)
        {
             try
            {
                 decimal  _value  =  Convert.ToDecimal(value);
                 return  _value;
            }
             catch
            {
                 return  defaultValue;
            }
        }

         ///   <summary>
         ///  转换成 Decimal 类型 [默认值 = -1]
         ///   </summary>
         ///   <param name="value"></param>
         ///   <returns></returns>
         public   static   decimal  ToDecimal( object  value)
        {
             return  ToDecimal(value,  - 1 );
        }
         #endregion

         #region  Double类型转换
         ///   <summary>
         ///  转换成 Double 类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   double  ToDouble( object  value,  double  defaultValue)
        {
             try
            {
                 double  _value  =  Convert.ToDouble(value);
                 return  _value;
            }
             catch
            {
                 return  defaultValue;
            }
        }

         ///   <summary>
         ///  转换成 Double 类型 [默认值 = -1]
         ///   </summary>
         ///   <param name="value"></param>
         ///   <returns></returns>
         public   static   double  ToDouble( object  value)
        {
             return  ToDouble(value,  - 1 );
        }
         #endregion

         #region  Int16类型转换
         ///   <summary>
         ///  转换成 short [Int16] 类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   short  ToInt16( object  value,  short  defaultValue)
        {
             try
            {
                 short  _value  =  Convert.ToInt16(value);
                 return  _value;
            }
             catch
            {
                 return  defaultValue;
            }
        }
         ///   <summary>
         ///  转换成 short [Int16] 类型 [默认值 = -1]
         ///   </summary>
         ///   <param name="value"></param>
         ///   <returns></returns>
         public   static   short  ToInt16( object  value)
        {
             return  ToInt16(value,  - 1 );
        }
         #endregion

         #region  Int32类型转换
         ///   <summary>
         ///  转换成 int[Int32] 类型 [默认值 = -1]
         ///   </summary>
         ///   <param name="value"></param>
         ///   <returns></returns>
         public   static   int  ToInt32( object  value)
        {
             return  ToInt32(value,  - 1 );
        }

         ///   <summary>
         ///  转换成 int[Int32] 类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   int  ToInt32( object  value,  int  defaultValue)
        {
             try
            {
                 return  Convert.ToInt32(value);
            }
             catch
            {
                 return  defaultValue;
            }
        }
         #endregion

         #region  Int64类型转换
         ///   <summary>
         ///  转换成 long[Int64] 类型
         ///   </summary>
         ///   <param name="value"></param>
         ///   <param name="defaultValue"> 当值无法转换时的默认值 </param>
         ///   <returns></returns>
         public   static   long  ToInt64( object  value,  long  defaultValue)
        {
             try
            {
                 long  _value  =  Convert.ToInt64(value);
                 return  _value;
            }
             catch
            {
                 return  defaultValue;
            }
        }

         ///   <summary>
         ///  转换成 long[Int64] 类型 [默认值 = -1]
         ///   </summary>
         ///   <param name="value"></param>
         ///   <returns></returns>
         public   static   long  ToInt64( object  value)
        {
             return  ToInt64(value,  - 1 );
        }
         #endregion

         ///   <summary>
         ///  将以符号分割的字符串转换成ArrayList类型
         ///   </summary>
         ///   <param name="content"></param>
         ///   <param name="splitChar"> 分割符如：, </param>
         ///   <returns></returns>
         public   static  ArrayList StringToArrayList( string  content,  char  splitChar)
        {
            ArrayList al  =   new  ArrayList();
             foreach  ( string  str  in  content.Split(splitChar))
            {
                al.Add(str);
            }
             return  al;
        }

         #endregion
    }
}

 

转载于:https://www.cnblogs.com/netAICode/archive/2009/09/24/1572982.html