C#中As和强制转换的总结

C#是一门强类型语言，一般情况下，我们***避免将一个类型强制转换为其他类型，但有些时候难免要进行类型转换。先想想究竟哪些操作可以进行类型转换（先不考虑.NET提供的Parse）,一般我们都有以下选择：

创新互联公司是一家专注于成都网站建设、成都网站设计与策划设计,福安网站建设哪家好?创新互联公司做网站,专注于网站建设十载,网设计领域的专业建站公司;建站业务涵盖:福安等地区。福安做网站价格咨询:18980820575

  • 使用as操作符转换，
  • 使用传统C风格的强制转型，
  • 使用is来做一个转换测试，然后再使用as操作符或者强制转换。

正确的选择应该是尽可能地使用as操作符，因为它比强制转型要安全，而且在运行时层面也有比较好的效率（注意的是as和is操作符都不执行任何用户自定义的转换，只有当运行时类型与目标转换类型匹配时，它们才会转换成功）。

现在我们通过一个简单的例子说明as和强制转换之间的区别,首先我们定义一间获取不同类型对象的工厂，然后我们把未知类型转换为自定义类型。

 
 
 
    
  
  
  
  1. object o = Factory.GetObject();   
    2.   
  
  
  2. MyType t = o as MyType;   
    3.   
  
  
  3. if (t == null) { //转换成功 }   
    4.   
  
  
  4. else { //转换失敗 }   
    5.   
  
  
  5. object o = Factory.GetObject();   
    6.   
  
  
  6. try { MyType t = o as MyType;   
    7.   
  
  
  7. if (t != null)   
    8.   
  
  
  8. { ////转换成功   
    9.   
  
  
  9. }   
    10.   
  
  
  10. else   
    11.   
  
  
  11. {   
    12.   
  
  
  12. ////转换失敗   
    13.   
  
  
  13. }   
    14.   
  
  
  14. }   
    15.   
  
  
  15. catch   
    16.   
  
  
  16. { ////异常处理  
    17.   
  
  
  17.  } 
    18.

通过上述代码我们发现as类型转换失败时值为null不抛出异常，但强制转换如果转换失败会抛出异常所以我们要添加异常处理。

现在我们对as和强制转换有了初步的了解，假设现在我们定义了一个抽象类Foo，然后Foo1继承于它，并且再定义一个基类Logger，在Foo1中定义与Logger类型隐式转换具体如下：

 
 
 
    
  
  
  
  1. Foo1 myFoo;  
    2.   
  
  
  2. //// Inherits abstract class. Logger myFoo;   
    3.   
  
  
  3. //// base class. public class Foo1 : Foo { PRivate Logger _value;   
    4.   
  
  
  4. ///    
    5.   
  
  
  5. /// 隐式自定义类型转换。   
    6.   
  
  
  6. ///    
    7.   
  
  
  7. ///    
    8.   
  
  
  8. ///    
    9.   
  
  
  9. public static implicit Operator Logger(Foo1 foo1) { return foo1._value;   
    10.   
  
  
  10. }   
    11.   
  
  
  11. } 
    12.

现在我们猜猜看以下的类型转换是否成功（提示：从编译和运行时类型转换角度考虑）。

 
 
 
    
  
  
  
  1. object myFoo = container.Resolve();   
    2.   
  
  
  2. //获取未Foo1类型   
    3.   
  
  
  3. try { Logger myFoo1 = (Logger)myFoo;   
    4.   
  
  
  4. if (myFoo1 != null)   
    5.   
  
  
  5. {   
    6.   
  
  
  6. Console.WriteLine("Covert successful.");   
    7.   
  
  
  7. }   
    8.   
  
  
  8. }   
    9.   
  
  
  9. catch   
    10.   
  
  
  10. {   
    11.   
  
  
  11. Console.WriteLine("Covert failed.");   
    12.   
  
  
  12. } 
    13.

相信聪明的大家已经想出答案了，激动人心的时刻到了现在让我们公布答案：转换失败抛出异常。

首先我们要从编译和运行时角度来分析，在编译时myFoo的类型为System.Object，这时编译器会检测是否存在自定义由Object到Logger的类型转换。如果没有找到合适转换，编译器将生成代码检测myFoo的运行时类型和Logger比较，由于myFoo的运行时类型为Foo1,而且我们自定义了由Foo1到Logger的类型转换，估计这样可以转换成功了吧！然而恰恰没有转换成功，这究竟是什么原因呢？让我们了解一下编译器对于隐式类型转换的原理吧。

通过我们发现用户自定义的转换操作符只作用于对象的编译时类型，而非运行时类型上，OK现在让修改一下代码让我们编译器认识自定义类型中。

 
 
 
    
  
  
  
  1. using (IUnityContainer container = new UnityContainer()) 
    2.   
  
  
  2. { UnityConfigurationSection 
    3.   
  
  
  3. section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");   
    4.   
  
  
  4. //获取container名称为CfgClass下的配置   
    5.   
  
  
  5. section.Containers["CfgClass"].Configure(container);   
    6.   
  
  
  6. object tempFoo = container.Resolve();   
    7.   
  
  
  7. //获取未Foo1类型   
    8.   
  
  
  8. Foo1 myFoo = tempFoo as Foo1;   
    9.   
  
  
  9. //使用as先把object转型为Foo1   
    10.   
  
  
  10. try { Logger myFoo1 = (Logger)myFoo;   
    11.   
  
  
  11. if (myFoo1 != null) {   
    12.   
  
  
  12. Console.WriteLine("Covert successful.");   
    13.   
  
  
  13. }   
    14.   
  
  
  14. }   
    15.   
  
  
  15. catch {  
    16.   
  
  
  16. Console.WriteLine("Covert failed.");   
    17.   
  
  
  17. }   
    18.   
  
  
  18. Console.ReadKey();   
    19.   
  
  
  19. } 
    20.

现在类型可以转换成功，这是因为编译器使用了我们自定义的隐式转换，由于myFoo这次的编译类型为Foo1，编译器首先查找是否存在Foo1和Logger自定义转换类型，由于我们定义了一种由Foo1到Logger的隐式类型转换所以转换成功。

通过上述我们发现了as给我们带来的好处，但是有一点我们要注意的是as只能用于引用类型不能用于值类型。那我就有个问题了在进行类型转换之前如果我们并不知道要转换的是值类型还是引用类型，那该怎么办呢？现在是is登场的时候了。

 
 
 
    
  
  
  
  1. bject tempFoo = container.Resolve(); //获取未Foo1类型   
    2.   
  
  
  2. int myInt = tempFoo as int; //compile error 
    3.

as不能用于值类型，这是因为值类型不能为null（注意：C#2.0中，微软提供了Nullable类型，允许用它定义包含null值，即空值的数据类型）像这种情况我们应该使用强制类型转换。

 
 
 
    
  
  
  
  1. object tempFoo = container.Resolve();   
    2.   
  
  
  2. //获取未Foo1类型   
    3.   
  
  
  3. try { int myInt = (int)tempFoo;   
    4.   
  
  
  4. //转换成功   
    5.   
  
  
  5. if (myFoo1 != null)   
    6.   
  
  
  6. {   
    7.   
  
  
  7. Console.WriteLine("Covert successful.");   
    8.   
  
  
  8. }   
    9.   
  
  
  9. }   
    10.   
  
  
  10. catch   
    11.   
  
  
  11. { Console.WriteLine("Covert failed.");   
    12.   
  
  
  12. } 
    13.

大家可以发现和我们之前使用的强制转换类似，而且还有处理异常，现在修改一下我们代码让它更加简洁实现如下：

 
 
 
    
  
  
  
  1. object tempFoo = container.Resolve();   
    2.   
  
  
  2. //获取未Foo1类型int i = 0;   
    3.   
  
  
  3. //值类型转换  
    4.   
  
  
  4. if (tempFoo is int){ i = (int) tempFoo;}  
    5.   
  
  
  5. object tempFoo = container.Resolve();   
    6.   
  
  
  6. //获取未Foo1类型  
    7.   
  
  
  7. Logger myFoo1 = null;   
    8.   
  
  
  8. //引用类型转换  
    9.   
  
  
  9. if (tempFoo is Logger)  
    10.   
  
  
  10. {   
    11.   
  
  
  11. myFoo1 = tempFoo as Logger;  
    12.   
  
  
  12. } 
    13.

总结

as和强制转换之间***的区别就在于如何处理用户自定义的转换。操作符 as和 is 都只检查被转换对象的运行时类型，并不执行其他的操作。如果被转换对象的运行时类型既不是所转换的目标类型，也不是其派生类型，那么转型将告失败。但是强制转型则会使用转换操作符来执行转型操作，这包括任何内建的数值转换（如：long转int）。

一般情况我们应该先考虑使用as进行类型转换，然后再考虑使用is,***才考虑使用强制转换。

网站栏目：C#中As和强制转换的总结
当前URL：http://www.shufengxianlan.com/qtweb/news43/65843.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

同城分类信息

网站seo优化　　 　成都网站推广　　 　成都做网站　　 　成都网站制作　　 　堡垒主机　　 　西云服务器托管　　 　济桢教育　　 　旅游网站建设方案　　 　seo关键词优化　　 　成都门窗定制　　 　广安做网站　　 　B2C电商系统　　 　服务器托管　　 　中国电信成都枢纽中心　　 　网站设计　　 　宜宾做网站　　 　seo优化　　 　微信公众号开发　　 　电信服务器托管　　 　成都网站建设