C#中各种数据类型转换的方法的类

最新推荐文章于 2023-02-27 07:00:00 发布
最新推荐文章于 2023-02-27 07:00:00 发布
阅读量778 收藏 1
点赞数 1
文章标签： c#
原文链接：http://www.cnblogs.com/kevinGao/archive/2011/11/04/2671034.html
版权

//各种数据类型转换方法的类
    public class GF_Convert
    {
        /// <summary>
        /// 字符串 转换 char数组
        /// </summary>
        /// <param name="in_str"></param>
        /// <param name="in_len"></param>
        /// <returns></returns>
        public static char[] string2chararray(string in_str, int in_len)
        {
            char[] ch = new char[in_len];
            in_str.ToCharArray().CopyTo(ch, 0);
            return ch;
        }

        /// <summary>
        /// char数组 转换 字符串
        /// </summary>
        /// <param name="in_str"></param>
        /// <returns></returns>        
        public static string chararray2string(char[] in_str)
        {
            string out_str;
            out_str = new string(in_str);
            int i = out_str.IndexOf('\0', 0);
            if (i == -1)
                i = 16;
            return out_str.Substring(0, i);
        }
        
        /// <summary>
        /// byte数组 转换 字符串
        /// </summary>
        /// <param name="in_str"></param>
        /// <returns></returns>
        public static string bytearray2string(byte[] in_str)
        {
            string out_str;
            out_str = System.Text.Encoding.Default.GetString(in_str);
            return out_str.Substring(0, out_str.IndexOf('\0', 0));

        }

        /// <summary>
        /// 字符串 转换 byte数组  注意转换出来会使原来的bytearray长度变短
        /// </summary>
        /// <param name="in_str"></param>
        /// <returns></returns>
        public static byte[] string2bytearray(string in_str)
        {
            return System.Text.Encoding.Default.GetBytes(in_str);
        }

        /// <summary>
        /// 字符串 转换 byte数组  长度为传如的长度
        /// </summary>
        /// <param name="in_str">传入字符串</param>
        /// <param name="iLen">目标字节数组长度</param>
        /// <returns></returns>
        public static byte[] string2bytearray(string in_str, int iLen)
        {
            byte[] bytes = new byte[iLen];
            byte[] bsources=System.Text.Encoding.Default.GetBytes(in_str);
            Array.Copy(bsources, bytes, bsources.Length);
            
            
            return bytes;
        }
        
        /// <summary>
        /// 将字符串编码为Base64字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string Base64Encode(string str)
        {
            byte[] barray;
            barray = Encoding.Default.GetBytes(str);
            return Convert.ToBase64String(barray);
        }

        /// <summary>
        /// 将Base64字符串解码为普通字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string Base64Decode(string str)
        {
            byte[] barray;
            try
            {
                barray = Convert.FromBase64String(str);
                return Encoding.Default.GetString(barray);
            }
            catch
            {
                return str;
            }
        }

        /// <summary>
        /// 图片 转换 byte数组
        /// </summary>
        /// <param name="pic"></param>
        /// <param name="fmt"></param>
        /// <returns></returns>
        public static byte[] image_Image2Byte(Image pic, System.Drawing.Imaging.ImageFormat fmt)
        {
            MemoryStream mem = new MemoryStream();
            pic.Save(mem, fmt);
            mem.Flush();
            return mem.ToArray();
        }
        /// <summary>
        /// byte数组 转换 图片
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static Image image_Byte2Image(byte[] bytes)
        {
            MemoryStream mem = new MemoryStream(bytes, true);
            mem.Read(bytes, 0, bytes.Length);
            mem.Flush();
            Image aa = Image.FromStream(mem);
            return aa;
        }
                
        /// <summary>
        /// ip 转换 长整形
        /// </summary>
        /// <param name="strIP"></param>
        /// <returns></returns>
        public static long IP2Long(string strIP)
        {

            long[] ip = new long[4];

            string[] s = strIP.Split('.');
            ip[0] = long.Parse(s[0]);
            ip[1] = long.Parse(s[1]);
            ip[2] = long.Parse(s[2]);
            ip[3] = long.Parse(s[3]);

            return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];
        }

        /// <summary>
        /// 长整形 转换 IP
        /// </summary>
        /// <param name="longIP"></param>
        /// <returns></returns>
        public static string Long2IP(long longIP)
        {


            StringBuilder sb = new StringBuilder("");
            sb.Append(longIP >> 24);
            sb.Append(".");

            //将高8位置0，然后右移16为


            sb.Append((longIP & 0x00FFFFFF) >> 16);
            sb.Append(".");


            sb.Append((longIP & 0x0000FFFF) >> 8);
            sb.Append(".");

            sb.Append((longIP & 0x000000FF));


            return sb.ToString();
        }

        /// <summary>
        /// 将8位日期型整型数据转换为日期字符串数据
        /// </summary>
        /// <param name="date">整型日期</param>
        /// <param name="chnType">是否以中文年月日输出</param>
        /// <returns></returns>
        public static string FormatDate(int date, bool chnType)
        {
            string dateStr = date.ToString();

            if (date <= 0 || dateStr.Length != 8)
                return dateStr;

            if (chnType)
                return dateStr.Substring(0, 4) + "年" + dateStr.Substring(4, 2) + "月" + dateStr.Substring(6) + "日";

            return dateStr.Substring(0, 4) + "-" + dateStr.Substring(4, 2) + "-" + dateStr.Substring(6);
        }


        /// <summary>
        /// string型转换为bool型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的bool类型结果</returns>
        public static bool StrToBool(object expression, bool defValue)
        {
            if (expression != null)
                return StrToBool(expression, defValue);

            return defValue;
        }

        /// <summary>
        /// string型转换为bool型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的bool类型结果</returns>
        public static bool StrToBool(string expression, bool defValue)
        {
            if (expression != null)
            {
                if (string.Compare(expression, "true", true) == 0)
                    return true;
                else if (string.Compare(expression, "false", true) == 0)
                    return false;
            }
            return defValue;
        }
        
        /// <summary>
        /// 将对象转换为Int32类型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static int ObjectToInt(object expression)
        {
            return ObjectToInt(expression, 0);
        }

        /// <summary>
        /// 将对象转换为Int32类型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static int ObjectToInt(object expression, int defValue)
        {
            if (expression != null)
                return StrToInt(expression.ToString(), defValue);

            return defValue;
        }
        
        /// <summary>
        /// 将对象转换为Int32类型,转换失败返回0
        /// </summary>
        /// <param name="str">要转换的字符串</param>
        /// <returns>转换后的int类型结果</returns>
        public static int StrToInt(string str)
        {
            return StrToInt(str, 0);
        }

        /// <summary>
        /// 将对象转换为Int32类型
        /// </summary>
        /// <param name="str">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static int StrToInt(string str, int defValue)
        {
            if (string.IsNullOrEmpty(str) || str.Trim().Length >= 11 || !Regex.IsMatch(str.Trim(), @"^([-]|[0-9])[0-9]*(\.\w*)?$"))
                return defValue;

            int rv;
            if (Int32.TryParse(str, out rv))
                return rv;

            return Convert.ToInt32(StrToFloat(str, defValue));
        }

        /// <summary>
        /// string型转换为float型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static float StrToFloat(object strValue, float defValue)
        {
            if ((strValue == null))
                return defValue;

            return StrToFloat(strValue.ToString(), defValue);
        }

        /// <summary>
        /// string型转换为float型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static float ObjectToFloat(object strValue, float defValue)
        {
            if ((strValue == null))
                return defValue;

            return StrToFloat(strValue.ToString(), defValue);
        }

        /// <summary>
        /// string型转换为float型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static float ObjectToFloat(object strValue)
        {
            return ObjectToFloat(strValue.ToString(), 0);
        }

        /// <summary>
        /// string型转换为float型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <returns>转换后的int类型结果</returns>
        public static float StrToFloat(string strValue)
        {
            if ((strValue == null))
                return 0;

            return StrToFloat(strValue.ToString(), 0);
        }

        /// <summary>
        /// string型转换为float型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static float StrToFloat(string strValue, float defValue)
        {
            if ((strValue == null) || (strValue.Length > 10))
                return defValue;

            float intValue = defValue;
            if (strValue != null)
            {
                bool IsFloat = Regex.IsMatch(strValue, @"^([-]|[0-9])[0-9]*(\.\w*)?$");
                if (IsFloat)
                    float.TryParse(strValue, out intValue);
            }
            return intValue;
        }

        /// <summary>
        /// 将对象转换为日期时间类型
        /// </summary>
        /// <param name="str">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static DateTime StrToDateTime(string str, DateTime defValue)
        {
            if (!string.IsNullOrEmpty(str))
            {
                DateTime dateTime;
                if (DateTime.TryParse(str, out dateTime))
                    return dateTime;
            }
            return defValue;
        }

        /// <summary>
        /// 将对象转换为日期时间类型
        /// </summary>
        /// <param name="str">要转换的字符串</param>
        /// <returns>转换后的int类型结果</returns>
        public static DateTime StrToDateTime(string str)
        {
            return StrToDateTime(str, DateTime.Now);
        }

        /// <summary>
        /// 将对象转换为日期时间类型
        /// </summary>
        /// <param name="obj">要转换的对象</param>
        /// <returns>转换后的int类型结果</returns>
        public static DateTime ObjectToDateTime(object obj)
        {
            return StrToDateTime(obj.ToString());
        }

        /// <summary>
        /// 将对象转换为日期时间类型
        /// </summary>
        /// <param name="obj">要转换的对象</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static DateTime ObjectToDateTime(object obj, DateTime defValue)
        {
            return StrToDateTime(obj.ToString(), defValue);
        }

        /// <summary>
        /// 替换回车换行符为html换行符
        /// </summary>
        public static string StrFormat(string str)
        {
            string str2;

            if (str == null)
            {
                str2 = "";
            }
            else
            {
                str = str.Replace("\r\n", "<br />");
                str = str.Replace("\n", "<br />");
                str2 = str;
            }
            return str2;
        }

        /// <summary>
        /// 转换为简体中文
        /// </summary>
        public static string ToSChinese(string str)
        {
            return Strings.StrConv(str, VbStrConv.SimplifiedChinese, 0);
            
        }

        /// <summary>
        /// 转换为繁体中文
        /// </summary>
        public static string ToTChinese(string str)
        {
            return Strings.StrConv(str, VbStrConv.TraditionalChinese, 0);
            
        }


        /// <summary>
        /// 清除字符串数组中的重复项
        /// </summary>
        /// <param name="strArray">字符串数组</param>
        /// <param name="maxElementLength">字符串数组中单个元素的最大长度</param>
        /// <returns></returns>
        public static string[] DistinctStringArray(string[] strArray, int maxElementLength)
        {
            Hashtable h = new Hashtable();

            foreach (string s in strArray)
            {
                string k = s;
                if (maxElementLength > 0 && k.Length > maxElementLength)
                {
                    k = k.Substring(0, maxElementLength);
                }
                h[k.Trim()] = s;
            }

            string[] result = new string[h.Count];

            h.Keys.CopyTo(result, 0);

            return result;
        }

        /// <summary>
        /// 清除字符串数组中的重复项
        /// </summary>
        /// <param name="strArray">字符串数组</param>
        /// <returns></returns>
        public static string[] DistinctStringArray(string[] strArray)
        {
            return DistinctStringArray(strArray, 0);
        }
        
        }
       


转载于:https://www.cnblogs.com/kevinGao/archive/2011/11/04/2671034.html

weixin_34032792
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#基础之数据类型转换
01-01
上面的代码中，由于long变量的值超过了int能容纳的最大值，造成了数据的丢失；像这样有可能造成数据丢失或引发异常的任何转换都需要执行显式转换(explicit); 相反的就是执行隐式转换(implicit). 　用chencked检查...
C#精挑整理知识要点5 类型转换（建议收藏）
Mr、黄
08-23 883
1.概念 C# 是一门强类型语言，对类型要求比较严格，但是在一定的条件下也是可以相互转换的，如将 int 型数据转换成 double 型数据。 C# 允许使用两种转换方式：隐式类型转换和显式类型转换。 1.隐式类型转换 隐式类型转换是 C# 默认的以安全方式进行的转换，不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。 隐式转换主要是在整型、浮点型之间的转换，将存储范围小的数据类型直接转换成存储范围大的数据类型 例： int a = 100; double d = a; floa
C语言下的ip与long之间的互换(long2ip,ip2long)
weixin_33970449的博客
01-08 219
代码 #include &lt;stdio.h&gt;#include &lt;winsock.h&gt;char *long2ip(u_long in);u_long ip2long(char *ip);int main(){    char p[16];    printf("请输入IP地址:\n");    scanf("%s",p);    u_long l = ip2long(p)...
ip2long和long2ip的学习程序
sofire的专栏
08-08 163
这2个是PHP里面的常用函数，用D重新包装了一下。 虽然可以使用，但没有错误判断。 顺便练习了一下C字符串和D字符串之间的转换。 [code] import std.stdio; import std.string; extern(C) { uint ntohl(uint); uint inet_addr(char *cp); uint h...
C#中的数据类型转换
无
08-19 5406
开发工具与关键技术： MVC 撰写时间：2021/8/18 下面我们来讲C#中数据类型的转换； 1.C#中的数据类型转换分为两种：隐式类型转换以及显式类型转换； （1）隐式类型转换：将存储范围小的数据类型直接转换为存储范围大的数据类型。 例如： 隐式转换大致分为以下几种： 隐式数值转换实际上就是从低精度的数值类型到高精度的数值类型的转换 （2）C#中的显式类型转换： 转换语法：数据类型 变量名 = （数据类型） 变量名或值 例如： 2.常用的数据类型转换方法： （1）Parse（）方法：对于string
c#之用户定义的数据类型转换介绍
12-25
c# 允许用户进行两种定义的数据类型转换，显式和隐式，显式要求在代码中显式的标记转换，其方法是在圆括号中写入目标数据类型。 对于预定义的数据类型，当数据类型转换时可能失败或丢失某些数据，需要显式转换， 1 ...
详解C# 泛型中的数据类型判定与转换
08-18
主要介绍了C# 泛型中的数据类型判定与转换，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
浅析C#数据类型转换的几种形式
01-01
1、Convert.ToInt32(); //转换成32位的整数。2、变量.ToString();/最常见的转换成 字符串。3、”订单”+2514 //后面的数字会转换为字符串。4、((类名A)对象名X) //强行将 ...隐式数值C#数据类型转换：从 sbyte 到 sho
C# 通用类型转换方法
06-19
此方法能转换几乎所有简单的值类型以及实现了强制类型转换的引用类型，此方法利用反射和lambda实现，由于此方法是在大约2010年左右写的，当时个人知识有限对反射了解不深，没有将元数据中的方法成功转换成委托以达到...
C# 各数据类型转换大全((int),Convert,Parse,TryParse,as,is，Type(),typeof)
lvxingzhe3的博客
12-11 3806
C#类型转换与比较,(int),Convert,Parse,TryParse,as,is，Type(),typeof归纳总结.
C#之(Virtual)虚拟与(abstract)抽象
无糖加冰
06-16 5560
继承过程中的疑难杂症(四,(Virtual)虚拟与(abstract)抽象) 在上篇我们讲解了override（重写）与overload（重载）,里面涉及到了虚拟方法和抽象方法,所以我们现在重点把(Virtual)虚拟与(abstract)抽象,在这里给大家详细讲解一下 override（重写）与overload（重载）详解 一,(Virtual)虚拟 在 C# 语言中，virtual是虚拟的含义,默认情况下类中的成员都是非虚拟的. 我们将类中的成员定义成虚拟的，表示这些成员将会在继承后重写其中的内容。
C#中虚方法(virtual)详解
热门推荐
凭时间赢来的东西，时间肯定会为之作证
06-17 15万+
虚方法如何定义? 虚方法怎么声明? 虚方法的规则是什么? 虚方法如何进行调用? 虚方法的作用是什么? 虚方法有什么好处? 虚方法使用时注意什么?
【笔记】C# 数据类型转换
好学若饥，谦卑若愚。
02-27 3117
自行整理的C#数据类型转换笔记。
C#中的类型转换
m0_68036090的博客
06-17 4521
开发工具与关键技术： VS Code/作者：梁水秀撰写时间：2022/6/17一、类型转换C#中类型转换 基本的两种:隐式类型转换和显示类型转换1、隐式转换: 由编译器自动操作,将数据类型长度小的变量转换为数据类型长度大的变量。实际上就是从低精度的数值类型到高精度的数值类型的转换。实例代码: 2、显示转换:显式类型转换，即强制类型转换。强制类型转换主要用于将存储范围大的数据类型转换成存储范围小的，但数据类型需要兼容。强制类型转换的语法： 实例代码:显式类型转换需要强制转换运算符，将表示范围大的类型变量转
2021-08-29
hxl200209的博客
08-29 336
C#中的类型转换 一、类型转换概念 C# 是一门强类型语言，对类型要求比较严格，但是在一定的条件下也是可以相互转换的， 如将 int 型数据转换成 double 型数据。 C# 允许使用两种转换方式：隐式类型转换和显式类型转换。 1、 隐式类型转换 隐式类型转换是 C# 默认的以安全方式进行的转换，不会导致数据丢失。例如，从小的整数 类型转换为大的整数类型，从派生类转换为基类。 隐式转换主要是在整型、浮点型之间的转换，将存储范围小的数据类型直接转换成存储范围 大的数据类型。 示例代码如下： 1 int
C#关键字——virtual浅见
abraham_ly的博客
06-12 6837
C#关键字——virtual的浅见 本篇文章主要讲解c#中virtual关键字的用法，希望对远道而来您能有一些帮助，准备好了嘛？那么咱们就一起开车喽! —————————————————————— 1、了解virtual的意思 由上图可知，virtual译为真实的，同时也有虚拟的意思，也就是说它是仿真的，但在c#中它是虚拟的。 下面我们一起来了解一下virtual关键字在c#中的用法合集 2、virtual关键字的使用范围 ​ virtual关键字只能用于修饰基类的方法（普通方法）、属性、索引器或事件
了解下C# 类型转换
Free雅轩的博客
01-26 973
类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。 在 C# 中，类型铸造有两种形式： 隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。 显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。 下面的实例显示了一个显式的类型转换：实例 namespace TypeConversionApplication { class
c#的数据类型转换方法
weixin_57726539的博客
02-27 5300
在编写代码的过程中数据类型之间的转换是必不可少的，下面介绍C#中的基本数据类型转换吧！ c#中数据类型转换的方法有两种，Parse 方法和Convert方法。 1、Parse 方法 C# Parse 方法用于将字符串类型转换成任意基本类型. 具体的语法形式如下。 基本数据类型.Parse(字符串类型的值); 这里要求等号左、右两边的数据类型兼容。 以下是示例： 2、Convert方法 Convert 方法是数据类型转换中最灵活的方法，它能够将任意数据类型的值转换成任意数据 .
c#数据类型转换方法
最新发布
12-12
C#中的数据类型转换分为两种：隐式类型转换和显式类型转换。 1. 隐式类型转换：将存储范围小的数据类型直接转换为存储范围大的数据类型。例如： ```csharp int num = 10; double dNum = num; // 隐式类型转换，将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值