.NET面试题系列[4] - C# 基础知识(2)

2 类型转换

面试出现频率:主要考察装箱和拆箱。对于有笔试题的场合也可能会考一些基本的类型转换是否合法。

重要程度:10/10

CLR最重要的特性之一就是类型安全性。在运行时,CLR总是知道一个对象是什么类型。对于基元类型之间的相互转换,可以显式或者隐式执行,例如将一个int转换为long。但如果将精度较大的类型转化为精度较小的类型,必须显式执行,且可能会丢失精度,但不会发生异常。可以利用checked关键字强制掷出OverflowException异常。

CLR允许将一个对象转化为它的任何基类型。C#不要求任何特殊语法即可将一个对象转换为它的任何基类型。然而,将对象转换为它的某个派生类型时,C#要求开发人员只能进行显式转换,因为这样的转换可能在运行时失败。

2.1 基元类型的类型转换

对基元类型进行转换时,可以显式或者隐式执行。如果遇到丢失精度的情况,C#将会向下取整(即无论如何都是舍去)。例如,对int的最大值转换为byte,将会得到255。对一个小数位精度较高的数转化为小数位精度较低的数,则简单的舍去多余的小数位。

1 int a = int.MaxValue;
2 Console.WriteLine(a);
3 byte b = (byte) a;             //255

如果去掉(byte),改为隐式执行,则会无法通过编译。可以利用checked关键字检查是否有溢出的情况。

1             checked
2             {
3                 byte b = (byte)a;             //Overflow
4                 Console.WriteLine(a + 1);     //Overflow
5                 Console.WriteLine(b);
6             }

也可以使用unchecked关键字忽略所有的精度和溢出检查。但由于这就是编译器的默认行为,所以unchecked关键字很少用到。

2.2 引用类型之间的类型转换

可以将一个对象转化为它的任何基类型。转换时,将等号右边的和左边的类型进行比较。如果左边的是基类,则安全,否则发生编译时异常,必须进行显式转换。例如object a = new Manager可以读为:Manager是一个object,所以这个(隐式)转换是安全的。但反过来就错误。显式转换永远发生运行时而不是编译时异常。

例如下面的测试题,假定有如下的定义:

1     public class B
2     {
3 
4     }
5 
6     public class D : B
7     {
8 
9     }

回答下面每一行代码是可以执行,还是造成编译时错误,或运行时错误:

Object o1 = new Object();

可以执行。

Object o2 = new B();

可以执行。这将会在栈上新建一个名为o2的对象,类型为Object。他指向堆上的B类型对象。因为Object类型是B的基类,所以类型安全。但由于o2的类型是Object,o2将只拥有Object的那几个方法(你可以自行在IDE中试验一下)。如果你执行Console.WriteLine(o2.GetType()),你会得到[命名空间名称].B,也就是说,GetType返回指向的类型对象的具体类型名称

Object o3 = new D();

可以执行,原因同上。

Object o4 = o3;

可以执行,可以将其看成Object o4 = new D();

在执行完上面四句话之后,内存中的状况如图:

如果你执行Console.WriteLine(object.ReferenceEquals(o3, o4)),会得到true的返回值,因为它们指向同一个实例。我们继续往下看:

B b1 = new B();

可以执行。

B b2 = new D();

可以执行。原因同第二个。

D d1 = new D();

可以执行。

B b3 = new Object();

编译时错误。不能将Object类型转为B。

D d2 = new Object();

编译时错误。原因同上。在执行完上面所有语句之后,内存中的状况如图(省略了类型对象指针):

B b4 = d1;

可以执行因为左边的B是基类,d1是派生类D。

D d3 = b2;

编译时错误。左边的是派生类,而b2的类型是B(在栈上的类型)。

D d4 = (D) d1;

可以执行。因为d1也是D类型,故没有发生实际转换。在执行完上面所有语句之后,内存中的状况如图(省略了类型对象指针):

D d6 = (D) b1;

运行时错误。在显式转换中,b1的类型是B,不能转换为其派生类D。通过显式转换永远不会发生编译时错误。

B b5 = (B) o1;

运行时错误。在显式转换中,o1的类型是基类Object,不能转换为其派生类B。

2.3 什么是拆箱和装箱?它们对性能的损耗体现在何处?

拆箱与装箱就是值类型与引用类型的转换,其是值类型和引用类型之间的桥梁。之所以可以这样转换是因为C#所有类型都源自Object(所有值类型都源于ValueType,而ValueType源于Object)。通过深入了解拆箱和装箱的过程,我们可以知道其包含了对堆上内存的操作,故其会消耗性能,因为这是完全不必要的。当了解了新建对象时内存的活动之后,装箱的内存活动就可以很容易的推断出来。

装箱的过程

对于简单的例子来说:

1 int x = 1023;
2 object o = x; //装箱

执行完第一句后,托管堆没有任何东西,栈上有一个整形变量。第二句就是装箱。因为object是一个引用类型,它必须指向堆上的某个对象,而x是值类型,没有堆上的对应对象。所以需要使用装箱,在堆上创造一个x。装箱包括了以下的步骤:

  1. 分配内存。这个例子中需要一个整形变量,加上托管堆上所有的对象都有的两个额外成员(类型对象指针和同步块索引)那么多的内存。类型对象指针指向int类型对象。
  2. 值类型的变量复制到新分配的堆内存。
  3. 返回对象的地址。

注意,不需要初始化int的类型对象,因为其在执行程序之前,编译之后,就已经被CLR初始化了。

拆箱的过程

拆箱并不是把装箱的过程倒过来,拆箱的代价比装箱低得多。拆箱不需要额外分配内存。

1             int i = 1;            
2             object o = i;
3             var j = (byte) o;

拆箱包括了以下的步骤:

  1. 如果已装箱实例为null,抛出NullReference异常
  2. 如果对象不是null但类型不是原先未装箱的值类型,则抛出InvalidCast异常,比如上面的代码
  3. 获取已装箱实例中值类型字段的地址
  4. 创建一个新的值类型变量,其值使用第三步获取到的值(复制)

通常避免无谓的装箱和拆箱,可以通过使用泛型,令对象成为强类型,从而也就没有了转换类型的可能。也可以通过IL工具,观察代码的IL形式,检查是否有关键字box和unbox。

2.4 使用is或as关键字进行类型转换

可以使用is或as关键字进行类型转换。

is将检测一个对象是否兼容于指定的类型,并返回一个bool。它永远不会抛出异常。如果转型对象是null,就返回false。典型的应用is进行类型转换的方式为:

 1 object o = new object();
 2 class A
 3 {
 4  
 5 }
 6 
 7 if (o is A)  //执行第一次类型兼容检查
 8 {
 9   A a = (A) o;  //执行第二次类型兼容检查
10 }

由于is实际上会造成两次类型兼容检查,这是不必要的。as关键字在一定程度上,可以改善性能。as永远不会抛出异常,如果转型对象是null,就返回null。典型的应用as进行类型转换的方式为:

1 object o = new object();
2 class B
3 {
4 }
5 B b = o as B;  //执行一次类型兼容检查
6 if (b != null)
7 {  
8   MessageBox.Show("b is B's instance.");
9 }

3. 字符串

面试出现频率:基本上肯定出现。特别是对字符串相加的性能问题的考察(因为也没有什么其他好问的)。如果你指出StringBuilder是一个解决方案,并强调一定要为其设置一个初始容量,面试官将会很高兴。

重要程度:10/10。

字符串是引用类型。可以通过字符串的默认值为null来记忆这点。string是基元类型String在c#中的别名,故这两者没有任何区别。

注意字符串在修改时,是在堆上创建一个新的对象,然后将栈上的字符串指向新的对象(旧的对象变为垃圾等待GC回收)。字符串的值是无法被修改的(具有不变性)。考虑使用StringBuilder来防止建立过多对象,减轻GC压力。

字符串的==操作和.Equal是相同的,因为==已经被重写为比较字符串的值而不是其引用。作为引用类型,==本来是比较引用的,但此时被重写,这也是字符串看起来像值类型的一个原因。

当使用StringBuilder时,如果你大概知道要操作的字符串的长度范围,请指明它的初始长度。这可以避免StringBuilder初始化时不断扩容导致的资源消耗。

你经常会有机会扩展这个类,例如为这个类扩展一个颠倒的字符串方法:

1     public static string Reverse(string s)
2     {
3         char[] charArray = s.ToCharArray();
4         Array.Reverse(charArray);
5         return new string(charArray);
6     }

3.1 字符串和普通的引用类型相比有什么特别的地方吗?

字符串的行为很像值类型:

  1. 字符串使用等于号互相比较时,比较的是字符串的值而不是是否指向同一个引用,这和引用类型的比较不同,而和值类型的比较相同。
  2. 字符串虽然是引用类型,但如果在某方法中,将字符串传入另一方法,在另一方法内部修改,执行完之后,字符串的值并不会改变,而引用类型无论是按值传递还是引用传递,值都会发生变化。

3.2 关于StringBuilder的性能问题

我们考虑将N个字符串连接起来的场景。在N极少时(小于8左右),StringBuilder的性能并不一定优于简单的使用+运算符。所以此时,我们不需要使用StringBuilder。

当N很大(例如超过100)时,StringBuilder的效能大大优于使用+运算符。

当N很大,但你知道N的确定数值时,考虑使用String.Concat方法。这个方法的速度之所以快,主要有以下原因:

  1. 当N确定,每个字符串也确定时,最终的字符串长度就确定了。此时,可以一次性为其分配这么大块的内存。而StringBuilder如果没有指明初始长度,或指定了一个较小的长度,则会不断扩容,消耗资源。扩容的动作分为如下几步:在内存中分配一个更大的空间,然后将现有的字符串复制过去(还余下一些空位for further use)
  2. StringBuilder有线程安全的考虑,故会拖慢一点时间

不过,如果你可以确定最终字符串长度的值,并将其作为初始长度分配给StringBuilder,则StringBuilder将不需要扩容,其性能将与String.Concat方法几乎相同(由于还有性能安全的考虑,故会稍微慢一点点)。

参考:

http://blog.zhaojie.me/2009/11/string-concat-perf-1-benchmark.html

http://blog.zhaojie.me/2009/12/string-concat-perf-2-stringbuilder-implementations.html

http://blog.zhaojie.me/2009/12/string-concat-perf-3-profiling-analysis.html

3.3 什么是字符串的不变性?

字符串的不变性指的是字符串一经赋值,其值就不能被更改。当使用代码将字符串变量等于一个新的值时,堆上会出现一个新的字符串,然后栈上的变量指向该新字符串。没有任何办法更改原来字符串的值。

3.4 字符串转换为值类型

有时我们不得不处理这样的情况,例如从WPF应用的某个文本框中获得一个值,并将其转换为整数。以int为例,其提供了两个静态方法Parse和TryParse。当转换失败时,Parse会掷出异常,使用Parse的异常处理比较麻烦:

 1 int quantity;
 2 try
 3 {
 4     quantity = int.Parse(txtQuantity.Text);
 5 }
 6 catch (FormatException)
 7 {
 8     quantity = 0;
 9 }
10 catch (OverflowException)
11 {
12     quantity = 0;
13 }

而TryParse不会引发异常,它会返回一个bool值提示转换是否成功:

1 int quantity;
2 if (int.TryParse(txtQuantity.Text, out quantity) == false)
3 {
4     quantity = 0;
5 }

代码变得十分简单易懂。当然,直接使用显式转换也是一种方法。显式转换和TryParse并没有显著的性能区别。

3.5 字符串的驻留(interning)

从来没有人问过我关于这方面的问题,我也是不久之前才学到的。简单来说,字符串驻留是CLR的JIT做代码优化时,送给我们的一个小礼物。CLR会维护一个字符串驻留池(内部哈希表),并在新建字符串时,探查是否已经有相同值的字符串存在。只有以下两种情况才会自动探查。

1. 如果编译器发现已经有相同值的字符串存在,则不新建字符串(在堆上),而是让新旧两字符串变量在栈上指向同一个堆上的字符串值。如果没有则在驻留池中增加一个新的成员。

var s1 = "123";
var s2 = "123";
Console.WriteLine(System.Object.Equals(s1, s2));  //输出 True
Console.WriteLine(System.Object.ReferenceEquals(s1, s2));  //输出 True

这意味着,堆上只有一条字符串“123”(隐式驻留)。如果我们预先知道许多字符串对象都可能有相同的值,就可以利用这点来提高性能。字符串的驻留的另一个体现方式是常量字符串相加的优化。下面例子输出结果也是两个True:

string st1 = "123" + "abc";
string st2 = "123abc";
Console.WriteLine(st1 == st2);
Console.WriteLine(System.Object.ReferenceEquals(st1, st2));

堆上的字符串只有一个 ----“123abc”。下面例子则稍有不同:

string s1 = "123";
string s2 = s1 + "abc";
string s3 = "123abc";
Console.WriteLine(s2 == s3);
Console.WriteLine(System.Object.ReferenceEquals(s2, s3));

第二个布尔值为False,因为变量和常量相加的动作不会被编译器优化

并非每次新建字符串,或者通过某种方式生成了一条新的字符串时,其都会被驻留。例如,上面例子中,变量字符串和常量字符串相加,就没有触发驻留行为,同理ToString,ToUpper等方法也不会(只有上面两种情况才会)。我们也可以通过访问驻留池来显式留用字符串。我们可以使用方法string.Intern为驻留池新增一个字符串,或者使用方法IsInterned探查字符串是否已经被驻留。

因为变量字符串和常量字符串相加无法利用驻留行为,所以无论我们怎么改进,上面的最后一行总是会输出False。例如:

string s1 = "123";
String.Intern("123abc");
string s2 = s1 + "abc";

string s3 = "123abc";
Console.WriteLine(s2 == s3);
Console.WriteLine(System.Object.ReferenceEquals(s2, s3));

此时s2的创建根本不会搭理驻留池。同理,这样也不行:

string s1 = "123";
String.Intern("123");
string s2 = 123.ToString();

Console.WriteLine(System.Object.ReferenceEquals(s2, s1));

通常来说,字符串驻留只有在常量字符串的分配和相加时才有意义。而且,我们要注意到字符串驻留的一个负面影响:驻留池的内存不受GC管辖,所以要到程序结束才会释放。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏深度学习思考者

Python学习(一)函数定义、使用与嵌套

一.函数的定义 Python编程中对于某些需要重复调用的程序,可以使用函数进行定义,基本形式为: def 函数名(参数1, 参数2, ……, 参数N): 其代码...

24770
来自专栏云霄雨霁

Java--多态性之内部类和匿名类

18360
来自专栏技术博客

编写高质量代码改善C#程序的157个建议[正确操作字符串、使用默认转型方法、却别对待强制转换与as和is]

  字符串应该是所有编程语言中使用最频繁的一种基础数据类型。如果使用不慎,我们就会为一次字符串的操作所带来的额外性能开销而付出代价。本条建议将从两个方面来探讨如...

11340
来自专栏前端杂货铺

深入instanceof

本文参考摘自这里 规范中 instanceof 运算符定义 11.8.6 The instanceof operator The production...

30280
来自专栏用户2442861的专栏

java final 关键字

http://blog.csdn.net/niguang09/article/details/6035813

10120
来自专栏数据之美

聊聊 Java 中 HashMap 初始化的另一种方式

如果你接触过不同的语言,从语法和代码层面来说,Java 是一种不折不扣的“臃肿、啰嗦”的语言,从另一方面来说这种臃肿和啰嗦也体现了它严谨的一面,作为适合构建大型...

2.3K100
来自专栏Esofar 开发日记

C#基础篇 - 理解委托和事件

委托类似于C++中的函数指针(一个指向内存位置的指针)。委托是C#中类型安全的,可以订阅一个或多个具有相同签名方法的函数指针。简单理解,委托是一种可以把函数当做...

13830
来自专栏于晓飞的专栏

Java 泛型进阶

在 List<String> 中添加 Integer 将不会通过编译,但是List<Sring>与List<Integer>在运行时的确是同一种类型。

22830
来自专栏女程序员的日常

值类型和引用类型的区别,struct和class的区别

C#值类型和引用类型 1、简单比较   值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。   值类型(value type):...

25810
来自专栏chenjx85的技术专栏

leetcode-482-License Key Formatting

15130

扫码关注云+社区

领取腾讯云代金券