`
sty2008boy
  • 浏览: 301774 次
  • 性别: Icon_minigender_1
  • 来自: 太原
社区版块
存档分类
最新评论

走进c#(类型转换的一个类Object对象转int String double byte[] Stream)

c# 
阅读更多 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace Test2
{
    class MyConvert
    {
        #region string转


        public static DateTime getDateTime(Object value)
        {
            try
            {
                if (value == null)
                {
                    return DateTime.Parse("0000/00/00 00:00:00");
                }
                switch(value.GetType().ToString())
                {
                    case "System.String":
                            return DateTime.Parse((String)value);
                    case "System.Int64":
                        return MyConvert.getDateTime(MyConvert.getString(value));
                    case "System.Int32":
                        return MyConvert.getDateTime(MyConvert.getString(value));
                    case "System.Boolean":
                        return MyConvert.getDateTime(MyConvert.getString(value));
                    case "System.Double":
                        return MyConvert.getDateTime(MyConvert.getString(value));
                    case "System.IO.MemoryStream":
                        return MyConvert.getDateTime(MyConvert.getString(value));
                    case "System.Byte[]":
                        return MyConvert.getDateTime(MyConvert.getString(value));
                    default:
                        return DateTime.Parse("0000/00/00 00:00:00");
                    
                }
              
            }
            catch(Exception) {
                return DateTime.Parse("0000/00/00 00:00:00");
            }
        }

        //string转换为Int32
        public static int getInt(Object value)
        {
            try
            {
                if (value == null)
                {
                    return 0;
                }
                switch(value.GetType().ToString())
                {
                    case "System.String":
                        return Int32.Parse((string)value);
                    case "System.Int64":
                        return Int32.Parse(((long)value).ToString());
                    case "System.Int32":
                        return (int)value;
                    case "System.Double":
                        return (int)System.Math.Round((double)value, 0);
                    case "System.Boolean":
                        return 0;
                    case "System.DateTime":
                        return 0;
                    case "System.IO.MemoryStream":
                        return MyConvert.getInt(MyConvert.getString(value));
                    case "System.Byte[]":
                        return MyConvert.getInt(MyConvert.getString(value));
                    default:
                        return 0;
                }
            }
            catch{
                return 0;
            }
        }

        //string转换为double
        public static double getDouble(Object value)
        {
            try
            {
               if(value==null)
               {
                   return 0.0;
               }
               switch (value.GetType().ToString()) 
               {
                   case "System.String":
                       return Double.Parse((string)value);
                   case "System.Int64":
                       return Double.Parse(((long)value).ToString());
                   case "System.Int32":
                       return Double.Parse(((int)value).ToString());
                   case "System.Boolean":
                       return 0.0;
                   case "System.Double":
                       return (int)System.Math.Round((double)value, 0);
                   case "System.DateTime":
                       return 0.0;
                   case "System.IO.MemoryStream":
                       return MyConvert.getInt(MyConvert.getString(value));
                   case "System.Byte[]":
                       return MyConvert.getInt(MyConvert.getString(value));
                   default:
                       return 0;
               }
            }
            catch
            {
                return 0.0;
            }
        }

        public static Stream getStream(Object value)
        {
            try
            {
                if (value == null)
                {
                    return new MemoryStream(Encoding.Default.GetBytes("null"));
                }
                switch (value.GetType().ToString()) 
                {
                    case "System.String":
                        return new MemoryStream(Encoding.Default.GetBytes((string)value));
                    case "System.Int64":
                        return new MemoryStream(Encoding.Default.GetBytes(MyConvert.getString(value)));
                    case "System.Int32":
                        return new MemoryStream(Encoding.Default.GetBytes(MyConvert.getString(value)));
                    case "System.Boolean":
                        return new MemoryStream(Encoding.Default.GetBytes(MyConvert.getString(value)));
                    case "System.DateTime":
                        return new MemoryStream(Encoding.Default.GetBytes(MyConvert.getString(value)));
                    case "System.Byte[]":
                        return new MemoryStream(Encoding.Default.GetBytes(MyConvert.getString(value)));
                    default:
                        return new MemoryStream(Encoding.Default.GetBytes("null"));
                }
            //    myStream = new MemoryStream(Encoding.Default.GetBytes(myString));
              //  Console.WriteLine(new StreamReader(myStream).ReadToEnd());
               // Console.WriteLine("myStream is " + myStream.Read());
            }
            catch{
                return new MemoryStream(Encoding.Default.GetBytes("null"));
            }
        }

        
         //string转换为byte[]
        public static byte[] getByte(Object value)
        {
            try
            {
                if (value == null) 
                {
                    return null;
                }
                switch(value.GetType().ToString())
                {
                    case "System.String":
                        return Encoding.Default.GetBytes((string)value);
                    case "System.Int64":
                        return Encoding.Default.GetBytes(MyConvert.getString(value));
                    case "System.Int32":
                        return Encoding.Default.GetBytes(MyConvert.getString(value));
                    case "System.Boolean":
                        return Encoding.Default.GetBytes(MyConvert.getString(value));
                    case "System.DateTime":
                        return Encoding.Default.GetBytes(MyConvert.getString(value));
                    case "System.IO.MemoryStream":
                        return Encoding.Default.GetBytes(MyConvert.getString(value));
                    default:
                        return null;
                
                }
            }
            catch
            {
                return null;
            }
        }
        #endregion
        /*******************************************
 * 
 *
 * 
 * ****************************************/
        #region 转string
        public static string getString(Object obj) 
        {
          
            switch (obj.GetType().ToString())
            { 
                case "System.DateTime":
                    Console.WriteLine(((DateTime)obj).ToLongDateString());
                    Console.WriteLine(((DateTime)obj).ToLongDateString().GetType());
                    return ((DateTime)obj).ToLongDateString();
                case "System.Int32":
                    Console.WriteLine(((Int32)obj).ToString());
                    Console.WriteLine(((Int32)obj).ToString().GetType());
                    return ((Int32)obj).ToString();
                case "System.Int64":
                   Console.WriteLine(((Int64)obj).ToString());
                   Console.WriteLine(((Int64)obj).ToString().GetType());
                   return ((Int64)obj).ToString();
                case "System.Double":
                    Console.WriteLine(((double)obj).ToString());
                    Console.WriteLine(((double)obj).ToString().GetType());
                    return ((double)obj).ToString();
                case "System.IO.MemoryStream":
                     Stream s = (Stream)obj;
                     StreamReader sr = new StreamReader(s);
                  string  myString=string.Empty;
                    while(sr.Peek()>-1)
                    {
                        string input = sr.ReadLine();
                        myString += input;
                    }
                     Console.WriteLine(myString);
                    Console.WriteLine(myString.GetType());
                    return myString;
                case "System.Byte[]":
                    return Encoding.UTF8.GetString((byte[])obj);
                case "System.Boolean":
                   if((bool)obj==false)
                       return "false";
                    else return "true";
                default:
                    Console.WriteLine("该格式无法转换");
                    return null;
            }
        }
        #endregion
    }
}
 
分享到：
| C#如何获取object对象的属性值
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    c#实现object与byte[]互转

    C#实现object与byte[]互转 在C#中，实现object与byte[]互转是一种常见的需求，特别是在网络通信和数据存储中。这篇文章将详细介绍如何将object转换为byte[]，并介绍相关的知识点。 序列化 序列化是将对象转换为二...

    c# 对象类型转换，包括时间转换、string 和int转换等

    c# 对象类型转换，包括时间转换、string 和int转换等

    c#中string转换成字节byte的处理方法

    该方法尝试将指定的字符串转换为一个8位无符号整数，即byte类型。 **示例代码：** ```csharp string str = "65"; byte data; try { data = Convert.ToByte(str); Console.WriteLine("转换成功：" + data); } ...

    C#中bitmap、stream、byte类型转换实例

    3. **byte**：在C#中，byte是一个值类型，它代表8位无符号整数，取值范围是0到255。在处理图像数据时，通常会将图像的每个像素表示为一个或多个byte。 现在，让我们看看如何进行这些转换： ### Bitmap到Stream转换...

    C#_string_byte数组转换解析

    在C#编程语言中，字符串（string）与字节数组（byte array）之间的转换是常见的操作，尤其在处理二进制数据、网络传输或文件读写时。本篇文章将详细解析C#中如何进行这两种数据类型的转换，并讨论转换过程中需要注意...

    Ｃ＋＋到Ｃ＃数据类型转换

    C++ 到 C# 数据类型转换 在软件开发中，数据类型转换是一个...C++ 到 C# 数据类型转换是一个非常重要的步骤。在软件开发中，正确地转换数据类型是非常必要的。只有正确地转换数据类型，才能确保软件的正确性和可靠性。

    c#数据类型转换,BYTE,float,double,char类型间的转换方法.docx

    在C#中，当你把一个值类型赋给一个对象引用时，就会发生装箱。例如： ```csharp int num = 10; object obj = num; // 装箱 int num2 = (int)obj; // 拆箱 ``` **数值类型间的转换** 在C#中，数值类型间的转换可以...

    C#中char[]与string之间的转换 string 转换成 Char[]

    C#中char[]与string之间的转换是一种常见的操作，我们经常需要在这两种数据类型之间进行转换。今天，我们将探讨C#中char[]与string之间的转换，包括string转换成Char[]和Char[]转换成string，同时也会涉及到byte[]与...

    C++和C#的类型转换

    在C++中，VARIANT是一个变体类型，在C#中，System.Object是一个对象类型。 22. PBYTE(byte *) ---- System.Byte[] 在C++中，PBYTE是一个字节指针，在C#中，System.Byte[]是一个字节数组类型。 23. LPTSTR ---- ...

    C#string转byte（16进制）代码.txt

    输入string 输出byte 16进制下的转换

    C# Byte数组转Int32 Short Float（浮点数）

    标题和描述提到的“C# Byte数组转Int32 Short Float（浮点数）”是指将字节数组中的数据转换为整型（Int32）、短整型（Short）以及浮点数（Float）的过程。以下是对这个主题的详细解释： **字节数组基础** 字节数组...

    常用类型转换扩展_C#_扩展_类型转换_

    1. **隐式类型转换（Implicit Conversion）**：当一个类型可以无损失地转换为另一个类型时，可以直接进行转换，例如`int`到`long`，`byte`到`int`等。 2. **显式类型转换（Explicit Conversion）**：当转换可能造成...

    C#强制类型转换

    在 C# 中，`int` 是一个关键字，表示 32 位有符号整数，它对应于 .NET Framework 中的 `System.Int32` 类型。`int` 类型可以隐式转换为 `long`、`float`、`double` 或 `decimal` 类型，但是从 `long` 类型到 `int` ...

    c# 对象与byte[]二进制流的转换帮助类

    系统自用，可把c#的对象存入txt文本或者数据库中 ，供下次直接使用，（double[,],List<double[]>等之类的对象）

    String(含Hex)与Byte数组互相转换[代码]

    在编程中，数据类型之间的转换是非常常见的操作，尤其是在处理二进制数据和文本数据时。在Java或类似的编程语言中，我们经常会遇到需要将字符串（String）与字节数组（Byte[]）以及十六进制表示的字符串（Hex）进行...

    C#实现实体类与字符串互相转换的方法

    这段代码中，`GetEntityToString`方法接收一个类型为T的实体类对象，使用反射获取该类型的属性信息，然后将每个属性的名称和值拼接成一个以逗号分隔的字符串。 接下来，我们将讨论如何将字符串转换回实体类。这个...

    C# 按照IEEE 754标准对Float和Double类型进行转换

    反之，`BitConverter.ToSingle(byte[])`和`BitConverter.ToDouble(byte[])`则可以将字节数组转换回浮点数。 另外，`BitConverter`还提供了`SingleToInt32Bits(float)`和`DoubleToInt64Bits(double)`方法，可以直接...

    Cstring 与BYTE类型之间转换

    1. **参数解析**：函数接受三个参数，其中`LPCTSTR shex`表示输入的十六进制字符串，`int &idec`是一个引用变量，用来存放转换后的十进制数。 2. **长度检查**：首先检查输入字符串的长度是否超过8个字符，如果超过...

    C#byte数组结构体互相转换示例.zip

    总结起来，这个"C#byte数组结构体互相转换示例"提供了C#中结构体与字节数组之间转换的实用方法，解决了开发过程中常见的序列化和反序列化需求，提高了代码效率。开发者可以根据自己的项目需求，直接引用或借鉴这些...

    《C#中的类型转换》

    例如，int到Int32的转换就是一个装箱过程，反之则是拆箱。值得注意的是，装箱后的值类型会被存储在托管堆上，而原始的值类型则存储在栈中。 C#中的别名是理解装箱和拆箱的关键。例如，int是System.Int32的别名，...

Magicbox
Global site tag (gtag.js) - Google Analytics