C# 基础类型转换_c#float转int-CSDN博客

本文链接：https://blog.csdn.net/TAB1771661075/article/details/144792363

一、简介

在C#中，类型转换是将一个数据类型的值转换为另一个数据类型的过程。类型转换在编程中是非常常见和重要的，它可以帮助我们在不同数据类型之间进行数据的传递和操作。

二、基本类型转换

在C#中，基本类型之间的转换是最常见和简单的类型转换。以下是C#中常见的基本类型转换：

整数类型之间的转换，比如int、long、short等；
浮点类型之间的转换，比如float、double等；
字符类型之间的转换，比如char；
布尔类型之间的转换，即bool类型。
在这一节中，我们将详细介绍每种基本类型之间的转换方式和注意事项。

1.整数类型转换

在C#中，整数类型之间的转换可以分为两类：隐式转换和显式转换。

1.隐式转换

隐式转换是指在编译时，C#编译器会自动进行的类型转换。隐式转换的规则如下：

从较小的整数类型向较大的整数类型转换，如从byte到int；
从有符号整数类型向无符号整数类型转换，如从int到uint；
从无符号整数类型向有符号整数类型转换，如从uint到int。

下面是一些示例代码：========

byte b = 10;
int i = b; // 隐式转换，byte转换为int
Console.WriteLine(i); // 输出结果：10

uint u = 20;
long l = u; // 隐式转换，uint转换为long
Console.WriteLine(l); // 输出结果：20

2.显式转换

显式转换是指在编译时，需要使用强制类型转换操作符来手动进行类型转换。显式转换的语法为：(目标类型)需要转换的值。
下面是一些示例代码：

double d = 3.14;
int i = (int)d; // 显式转换，double转换为int
Console.WriteLine(i); // 输出结果：3

float f = 1.5f;
int j = (int)f;       // 显式转换，float转换为int
Console.WriteLine(j); // 输出结果：1

2.浮点类型转换

在C#中，浮点类型之间的转换也可以分为隐式转换和显式转换。

1.隐式转换

隐式转换规则如下：

从较小的浮点类型向较大的浮点类型转换，如从float到double。
下面是一个示例代码：

float f = 3.14f;
double d = f; // 隐式转换，float转换为double
Console.WriteLine(d); // 输出结果：3.14

 float ee = 0.1f;
 double ff = (double)ee;
 //double hh = Math.Round(ff,2);
 Console.WriteLine(ee);
 //只有float 转double 会出现小数点后好多位
 decimal gg = (decimal)ee;
 Console.WriteLine(gg);

2.显式转换

显式转换的语法与整数类型转换相同。
下面是一个示例代码：

double d = 3.14;
float f = (float)d; // 显式转换，double转换为float
Console.WriteLine(f); // 输出结果：3.14

 float ee = 0.1f;
 double ff = (double)ee;
 //double hh = Math.Round(ff,2);
 Console.WriteLine(ee);
 //只有float 转double 会出现小数点后好多位
 decimal gg = (decimal)ee;
 Console.WriteLine(gg);

3.字符类型转换

在C#中，字符类型(char)的转换主要是与整数类型之间的转换。

1.字符到整数的转换

字符到整数的转换可以通过强制类型转换操作符进行。
下面是一个示例代码：

char c = 'A';
int i = (int)c; // 字符转换为整数
Console.WriteLine(i); // 输出结果：65

            char hh = 'a';
            int jj = hh;
            Console.WriteLine(jj);
            //可以隐式转换 只有 char 换 int 可以用
            //使用了ASCII码表 a b c 97 98 99


            int kk = 97;
            char ll = (char)kk;
            Console.WriteLine(ll);
            //使用了ASCII码表 a b c 97 98 99

强制转换!!!

如果有普通类型不能转换可以试试强制转换 Convert

bool zz = true;
long zz2 = Convert.ToInt64(zz);
//int 是32位 没有64位 如果要用int64 则需要用long接受
Console.WriteLine(zz2);

int xx = 0;
bool vv = Convert.ToBoolean(xx);
Console.WriteLine(vv);

int yy = 10;
object obj = yy;
Console.WriteLine(obj);
int zz3 = Convert.ToInt32(obj);
Console.WriteLine(zz3);

2.整数到字符的转换

整数到字符的转换也可以通过强制类型转换操作符进行。
下面是一个示例代码：

int i = 65;
char c = (char)i;     // 整数转换为字符
Console.WriteLine(c); // 输出结果：A

4.布尔类型转换

在C#中，布尔类型(bool)的转换主要是与整数类型之间的转换。

1.布尔到整数的转换

布尔到整数的转换可以通过隐式转换进行，true转换为1，false转换为0。

下面是一个示例代码：

bool bb = true;
int aa = Convert.ToInt32(bb)
Console.WriteLine(aa),

2.整数到布尔的转换

整数到布尔的转换也可以通过隐式转换进行，非零整数转换为true，零转换为false。
下面是一个示例代码：

int cc =1:
bool dd =Convert.ToBoolean(cc);
Console.WriteLine(dd);

三、隐式转换和显式转换

在前面的章节中，我们已经介绍了隐式转换和显式转换的概念和使用方法。在实际应用中，我们需要根据具体的需求来选择使用隐式转换还是显式转换。
隐式转换是自动进行的，不需要显式地指定类型转换操作符，但有可能会造成数据丢失。
显式转换需要使用强制类型转换操作符，可以精确地控制类型转换，但需要开发人员手动进行。
在使用隐式转换和显式转换时，我们需要注意数据溢出和精度丢失的问题，确保转换结果符合预期。

四、装箱和拆箱

在C#中，装箱(Boxing)和拆箱(Unboxing)是用于将值类型转换为引用类型和将引用类型转换为值类型的过程。
装箱是将值类型包装为引用类型的过程。拆箱是将引用类型转换为值类型的过程。
以下是装箱和拆箱的示例代码：

            // 装箱：值类型->引用类型
            int a = 20;
            object b = a;
            // 拆箱：引用类型->值类型
            a = Convert.ToInt32(b);
            int c;
            bool result = int.TryParse(b.ToString(), out c);

            // 拆箱案例
            char[] chars = { 'A', 'B', 'C' };
            string data = string.Join("", chars);
            // 理论效果："ABC"
            // 实际效果：System.Char[]
            Console.WriteLine(data);

装箱和拆箱的操作会带来一定的性能开销，因此在使用时需要谨慎考虑。

五、自定义类型转换

在C#中，我们还可以自定义类型转换，通过实现特定的方法来支持自定义类型之间的转换。
自定义类型转换需要使用到两个关键字：implicit和explicit。

implicit用于定义隐式转换方法；
explicit用于定义显式转换方法。

以下是自定义类型转换的示例代码：

public class MyClass
{
    public int Value { get; set; }

    public static implicit operator string(MyClass myClass)
    {
        return myClass.Value.ToString();
    }

    public static explicit operator int(MyClass myClass)
    {
        return myClass.Value;
    }
}

// 使用隐式转换
MyClass myClass = new MyClass { Value = 10 };
string str = myClass; // 隐式转换
Console.WriteLine(str); // 输出结果：10

// 使用显式转换
MyClass myClass2 = new MyClass { Value = 20 };
int i = (int)myClass2; // 显式转换
Console.WriteLine(i); // 输出结果：20

六、`GetType`和`typeof`

在C#中，我们可以使用GetType()方法获取对象的运行时类型，使用typeof()操作符获取类型的信息。

以下是使用GetType()和typeof()的示例代码：

string str = "Hello";
Type type = str.GetType(); // 获取对象的运行时类型
Console.WriteLine(type); // 输出结果：System.String

Type type2 = typeof(string); // 获取类型的信息
Console.WriteLine(type2); // 输出结果：System.String
    // get：获得
    // type：类型、种类
    // of：和、与、谁

    // GetType的用法

    // String和string本质没区别，都用于声明字符串变量
    // 为什么已知name是string还要获取它的Type??
    // gc CogGraphicLabel、CogLineSegment、CogCircle
    // 如果要为gc中的每个元素设置Text为123，行不行？？
    // 如果 元素的类型为 CogGraphicLabel，则设置Text
    // 否则 啥也不做
    string name = "张三";
    Type a = name.GetType();
    Console.WriteLine(a);

    Type b = typeof(int).GetType();
    // System.RuntimeType
    // Run运行  Time时间  Type类型
    // 运行时的类型
    Console.WriteLine(b);

//自己写的案例
 string str = "Name";
 Type type = str.GetType();
 Console.WriteLine(type);
 //展示  System.String  系统加2类型名称
 //GetType 要使用变量 "." 点出来 展示变量类型 后加 括号

 //typeof 则是直接使用类型 typeof() 括号里加变量
 int num = 978;
 Type type1 = typeof(int);
 Console.WriteLine(type1);
 //都适用   展示 System.Int32

七、`as`关键字和`is`关键字

在C#中，我们可以使用as关键字进行类型转换，并返回转换后的对象，如果转换失败则返回null。

以下是使用as关键字的示例代码：

object obj = "Hello";
string str = obj as string; // 使用as关键字进行类型转换
Console.WriteLine(str); // 输出结果：Hello

object obj2 = 10;
string str2 = obj2 as string; // 使用as关键字进行类型转换，转换失败返回null
Console.WriteLine(str2); // 输出结果：null

object obj2 = "num";
str = obj2 as string;
Console.WriteLine(str);
//as 只能是面向对象转字符串 不能是数字 
//只能实现 引用类型 接口类型 可为空值类型之间的转换

//失败时 显示null 也就是空 不显示
object obj3 = 10;
string str3 = obj3 as string; // 使用as关键字进行类型转换，转换失败返回null
Console.WriteLine(str3); // 输出结果：null

//反过来也可以展示 目前使用的是 面向对象 和 字符串之间
//只有非数值才能进行转换
string str4 = "Hello";
object obj4 = str4 as object;
Console.WriteLine(obj4);

而is关键字用于检查对象是否是指定类型的实例，返回一个布尔值。
以下是使用is关键字的示例代码：

object obj = "Hello";
bool isString = obj is string; // 检查对象是否是string类型的实例
Console.WriteLine(isString); // 输出结果：True

object obj2 = 10;
bool isString2 = obj2 is string; // 检查对象是否是string类型的实例
Console.WriteLine(isString2); // 输出结果：False
            // is的作用：判断该变量是否为某类型，返回值为bool

            // name = null; False
            // name = "";   True
            string name = "";
            bool isok = name is string;
            Console.WriteLine(isok);

            // as的作用：用于（优雅的）类型转换
            // 注意：不是所有类型都能通过as语句转换
            object a = 20;
            string b = a as string;

            string c = "";
            object d = c as object;
 object obj5 = "NiHao";
 bool isstring = obj5 is string;
 Console.WriteLine(isstring);

 obj = 23;
 isstring = obj is string;
 Console.WriteLine(isstring);

八、转换操作符

C#还提供了转换操作符，用于自定义类型之间的转换。
转换操作符分为隐式转换和显式转换，与前面的隐式转换和显式转换类似。
以下是转换操作符的示例代码：

public class MyClass
{
    public int Value { get; set; }
    public static implicit operator string(MyClass myClass)
    {
        return myClass.Value.ToString();
    }

    public static explicit operator int(MyClass myClass)
    {
        return myClass.Value;
    }
}

// 使用隐式转换
MyClass myClass = new MyClass { Value = 10 };
string str = myClass; // 隐式转换
Console.WriteLine(str); // 输出结果：10

// 使用显式转换
MyClass myClass2 = new MyClass { Value = 20 };
int i = (int)myClass2; // 显式转换
Console.WriteLine(i); // 输出结果：20

九、类型转换的注意事项

数据溢出：在进行类型转换时，需要确保目标类型的范围足够大以容纳源类型的值。否则，可能会发生数据溢出。例如，将一个很大的int转换为byte可能会导致数据丢失。
精度损失：在将浮点数转换为整数时，如果浮点数的小数部分不为0，则会丢失小数部分。同样，在进行其他精度较高的类型转换时，也需要注意精度损失的问题。
空引用异常：在进行引用类型的转换时，如果引用是null，那么在尝试访问其成员或方法时将会抛出空引用异常。因此，在进行引用类型的转换前，应该先检查引用是否为null。
自定义类型转换：虽然自定义类型转换可以方便地进行一些特殊类型的转换，但是也需要注意不要滥用。过多的自定义类型转换会使代码难以理解和维护。同时，由于这些转换发生在编译时，编译器无法对它们进行异常处理或数据验证，因此可能会引入一些难以察觉的错误。
可空值类型的处理：C#中的可空值类型可以很好地处理值为null的情况，但同时也需要考虑到可空值类型在参与算术运算时的空值传播问题。如果对一个可空值类型的变量进行算术运算，结果是null。
显式类型转换的安全性：显式类型转换操作符的使用需要谨慎，特别是对于可能存在空值的情况。使用dynamic_cast进行多态类型的转换时，需要注意转换失败的情况，如果转换失败，dynamic_cast会返回null。
隐式类型转换的局限性：虽然隐式类型转换很方便，但是也有一些局限性。例如，它不能用于函数重载的区分，也不能用于强制类型转换的表达式。此外，过多的隐式类型转换也可能会使代码难以理解。
注意数据类型的范围：在进行类型转换时，必须注意目标数据类型的范围是否能够容纳源数据的值。否则，可能会导致数据溢出或精度损失。
自定义类型转换的效率问题：自定义类型转换可能会导致额外的性能开销，因为编译器无法优化这些自定义操作。因此，在使用自定义类型转换时，需要考虑其对程序性能的影响。
避免不安全的类型转换：在C#中，有些类型转换可能会导致不安全的操作，例如从string转换为int。为了避免这种情况，应该尽量避免不安全的类型转换，而应该使用更安全的方式来处理数据。

总之，正确地使用类型转换是编写安全、高效、易维护的C#代码的关键之一。在使用类型转换时，需要充分考虑其可能带来的影响，并谨慎地使用它们。

总结

本篇文章介绍了C#中的类型转换，包括基本类型转换、隐式转换和显式转换、装箱和拆箱、自定义类型转换、GetType和typeof、as关键字和is关键字、转换操作符等内容。了解和掌握这些类型转换的知识对于编写高质量的C#代码非常重要。

============================

序号	方法	描述
1	ToBoolean	把类型转换为布尔型（如果可以转换的话）
2	ToByte	把类型转换为字节类型。
3	ToChar	把类型转换为单个 Unicode 字符类型（如果可以转换的话）
4	ToDateTime	把类型（整数或字符串类型）转换为日期-时间结构。
5	ToDecimal	把浮点型或整数类型转换为十进制类型。
6	ToDouble	把类型转换为双精度浮点型。
7	ToInt16	把类型转换为 16 位整数类型。
8	ToInt32	把类型转换为 32 位整数类型。
9	ToInt64	把类型转换为 64 位整数类型。
10	ToSbyte	把类型转换为有符号字节类型。
11	ToSingle	把类型转换为小浮点数类型。
12	ToString	把类型转换为字符串类型。
13	ToType	把类型转换为指定类型。
14	ToUInt16	把类型转换为 16 位无符号整数类型。
15	ToUInt32	把类型转换为 32 位无符号整数类型。
16	ToUInt64	把类型转换为 64 位无符号整数类型。