C# 4.0中COM互操作性和方差得到增强

原创
开发 后端
本文将介绍C# 4.0中增强的特性:COM互操作性以及方差,使得你现在在.NET代码中可以更容易地调用COM对象了,需要执行的类型转换更少了。

【51CTO独家特稿】这里将为大家介绍C# 4.0当中的COM互操作性以及方差这两个新特性。51CTO之前曾报道过C#4.0新特性一览及历史回顾

增强的COM互操作性特性

C# 4.0在COM互操作性支持方面提供了很多改进,使得你现在在.NET代码中可以更容易地调用COM对象了,需要执行的类型转换更少了,ref关键字不再需要,也不再需要主互操作程序集或PIA,从本质上讲,C# 4.0提供了大量的新特性,特别是在COM互操作方面更是下足了功夫,在前一篇文章中谈到的动态查询和命名/可选参数的支持,帮助提高了与COM API如Office自动化API互操作的体验。

例如,下面是C# 4.0以前的版本打开一个Word文件的代码:

  1. using Word = Microsoft.Office.Interop.Word;  
  2. namespace COMInterop  
  3. {  
  4.    class Program  
  5.    {  
  6.       static void Main(string[] args)  
  7.       {  
  8.          Word.Application wordApplication =   
  9.             new Word.Application() { Visible = true };  
  10.          object missingValue = System.Reflection.Missing.Value;  
  11.          object readOnlyValue = true;  
  12.          object fileName = @"C:\\DevX.docx";  
  13.          wordApplication.Documents.Open(ref fileName, ref   
  14.             missingValue, ref readOnlyValue,  
  15.             ref missingValue, ref missingValue,   
  16.             ref missingValue, ref missingValue,   
  17.             ref missingValue, ref missingValue,  
  18.             ref missingValue, ref missingValue,   
  19.            ref missingValue, ref missingValue,   
  20.            ref missingValue,ref missingValue);  
  21.       }  
  22.    }  

在最后的open调用中,你可以看到需要传递大量的可选参数以满足函数调用,随着C# 4.0中可选和命名参数的引入,现在做同样的事情,需要的代码要少得多了。

下面是C# 4.0中用来打开Word文档的代码:

  1. using Word = Microsoft.Office.Interop.Word;  
  2. namespace COMInterop  
  3. {  
  4.    class Program  
  5.    {  
  6.       static void Main(string[] args)  
  7.       {  
  8.          Word.Application wordApplication = new   
  9.             Word.Application() {Visible = true};     
  10.          wordApplication.Documents.Open(@"C:\\DevX.docx",   
  11.             ReadOnly: true);  
  12.       }  
  13.    }  

性能改善

PIA是由COM接口产生的,你可以在你的应用程序代码中使用这个程序集以一种强类型的方式与COM对象互操作,但它们很笨重,很消耗内存,会显著降低应用程序的性能。相反,互操作程序集通过前面的代码编译生成,只包含你的应用程序真正用到的互操作代码,从而大大减少了程序集的大小,提高了应用程序的性能。

动态导入大多数COM函数都是接收并返回变量类型,在PIA中表示为对象,因此,当你使用这些方法时,需要使用适当的强制类型转换,但在C# 4.0中,你可以使用dynamic关键字代替COM函数中的object,因此,现在不必再进行类型转换了。

思考一下下面的代码,你需要使用转换在excel文档中为某个特定单元格设置一个值:

  1. ((Excel.Range)excelObj.Cells[5, 5]).Value =   
  2.    "This is sample text"

上面的代码需要使用强制类型转换,但在C# 4.0中,你可以消除掉强制类型转换了,这一切都得感谢dynamic关键字,下面是C# 4.0中的实现方法:

  1. excelObj.Cells[55].Value = "This is sample text"

下面是一个更为完整的例子,使用的是C# 3.0代码保存excel文档:

  1. using Excel = Microsoft.Office.Interop.Excel;  
  2. namespace COMInterop  
  3. {  
  4.    class Program  
  5.    {  
  6.       static void Main(string[] args)  
  7.       {  
  8.          var excelApplication = new Excel.Application();  
  9.          excelApplication.Visible = true;  
  10.          dynamic excelWorkBook =   
  11.             excelApplication.Workbooks.Add(  
  12.             System.Reflection.Missing.Value);  
  13.          Excel.Worksheet wkSheetData = (  
  14.             Excel.Worksheet)excelWorkBook.ActiveSheet;  
  15.          excelWorkBook.SaveAs("Testfile.xls",   
  16.             System.Reflection.Missing.Value,   
  17.             System.Reflection.Missing.Value,  
  18.             System.Reflection.Missing.Value,   
  19.             System.Reflection.Missing.Value,   
  20.             System.Reflection.Missing.Value,  
  21.             Excel.XlSaveAsAccessMode.xlShared,   
  22.             System.Reflection.Missing.Value,   
  23.             System.Reflection.Missing.Value,  
  24.             System.Reflection.Missing.Value,   
  25.             System.Reflection.Missing.Value,   
  26.             System.Reflection.Missing.Value);  
  27.       }  
  28.    }  

在C# 4.0中,你不再需要使用缺失值和明确的强制类型转换了,下面是在C# 4.0中没有使用缺失值和强制类型转换的代码:

  1. using Excel = Microsoft.Office.Interop.Excel;  
  2. namespace COMInterop  
  3. {  
  4.    class Program  
  5.    {  
  6.       static void Main(string[] args)  
  7.       {  
  8.          var excelApplication = new Excel.Application();  
  9.          excelApplication.Visible = true;  
  10.          dynamic excelWorkBook = excelApplication.Workbooks.Add();  
  11.          Excel.Worksheet wkSheetData = excelWorkBook.ActiveSheet;  
  12.           excelWorkBook.SaveAs(  
  13.             "Testfile.xls",  
  14.             AccessMode: Excel.XlSaveAsAccessMode.xlShared);  
  15.       }  
  16.    }  

注意:COM有一个和托管代码完全不同的编程模型,为了调用COM函数,C#编译器允许你传递参数值,并会产生临时变量来保存这些值,当函数调用完毕后这些变量就会被丢掉。

方差支持

在C# 4.0中,你可以对泛型类型指定in(仅输入)好out(只返回)参数,这些参数可以作为唯一的输入参数或只作为这种类型的返回值被传递。

C# 4.0中对方差有两方面的支持:协方差和方差。如果你必须使用完全匹配正式类型的名称,那么返回的值或参数是不变的。如果你能够使用更多的衍生类型作为正式参数类型的代替物,那么参数是可变的。如果你能够将返回的类型分配给拥有较少类型的变量,那么返回的值是逆变的。

我这里不涉及任何不变量参数,你也应该从C#早期版本中熟悉了。

协方差

使用一个简单的例子更容易理解协方差,注意string是一个特殊的类型,而object是一个泛型类型,因此string是协变到object的。下面我们来看看C# 4.0中是如何支持协方差的,在C# 4.0中定义的IEnumerable接口如下:

  1. public interface IEnumerable : IEnumerable  
  2. {  
  3.    IEnumerator GetEnumerator();  
  4. }  
  5. public interface IEnumerator : IEnumerator  
  6. {  
  7.   bool MoveNext();  
  8.   T Current { get; }  

在c#的早期版本中,IEnumerable<string>不是IEnumerable<object>。注意前面Ienumerator<out T>定义中的out参数,它表明普通的T只可以在输出位置,否则编译器就会报告错误,T中的接口是协变的,意味着IEnumerable<P>也是 IEnumerable<Q>用P替换Q所得,因此,一个字符串序列也是一个对象序列,因此下面的语句完全有效:
IEnumerable<object> someObj = new List<string>();

下面的例子说明了你如何在C# 4.0中使用协方差:

  1. namespace Test  
  2. {  
  3.    class Base   
  4.    {  
  5.       //Methods and Properties of the Base Class  
  6.    }  
  7.    class Derived : Base   
  8.    {   
  9.       //Methods and Properties of the Derived Class  
  10.    }  
  11.    class Program  
  12.    {  
  13.       delegate T TestFunction<out T>();  
  14.       static void Main(string[] args)  
  15.       {  
  16.          TestFunction<Derived> derivedObj = () => new Derived();  
  17.          TestFunction<Base> baseObj = derivedObj;  
  18.       }  
  19.    }  

逆变性

C# 4.0中泛型接口的类型参数可以在in修饰字中,允许它们只出现在输入位置,例如:

  1. public interface IComparer<in T>  
  2. {  
  3.   public int Compare(T left, T right);  

因此,比较器既可以比较对象也可以比较字符串,这就叫做逆变性。逆变性的一个例子就是Equals()函数和CompareTo()函数。如果你有一个函数可以比较两个基类的实例,那么你也可以使用它比较两个派生类的实例,你可以在一个类型对象的实例中存储任何函数调用的结果,因为C#中函数返回的类型是逆变的。

下面是前面例子的逆变副本:

  1. namespace Test  
  2. {  
  3.    class Base   
  4.    {  
  5.      
  6.    }  
  7.    class Derived : Base   
  8.    {  
  9.      
  10.    }  
  11.    class Program  
  12.    {  
  13.       delegate void TestDelegate<in T>(T a);  
  14.       static void Main(string[] args)  
  15.       {  
  16.          TestDelegate<Base> baseObj = (obj) => {   
  17.             System.Console.WriteLine(obj); };  
  18.          TestDelegate<Derived> derivedObj = baseObj;  
  19.       }  
  20.    }  

注意:类型方差只能在接口和委派类型上工作,只有在类型参数之间存在引用转换才可以应用方差,因此,IEnumerable<int>不是IEnumerable<object>,因为int是一个值类型,object是一个引用类型,也就是说,整数到对象的转换是箱子转换,而不是一个引用转换,因此它不是一个方差的例子。

正如你所看到的,C# 4.0的新特性和主互操作程序集一起可以工作得更好,对可选参数的支持意味着你不用明确地传递缺失值给函数,而是用可选参数进行替代,对命名参数的支持意味着不用按照特定的顺序传递值,只要你使用了名称就可以识别,对方差的支持消除了许多冗长的,容易出错的强制类型转换,总而言之,这些都是十分有益的变化。

【编辑推荐】

  1. C#历史回顾及C# 4.0新特性一览
  2. 介绍C# 4.0新特性dynamic
  3. C# 4.0中的协变和逆变
  4. C# 4.0 Dynamic关键字全解析
  5. C# 4.0中泛型协变性和逆变性详解
责任编辑:彭凡 来源: 51CTO
相关推荐

2020-03-03 21:13:20

物联网融合互操作

2009-02-17 18:41:06

虚拟化红帽微软

2009-06-08 10:49:00

JavaFX互操作性Java互操作性

2017-02-06 11:50:12

NFV操作性测试

2017-02-06 14:34:24

NFV网络功能MANO

2012-09-07 09:51:07

云互操作性云可移植性云计算服务

2023-10-13 09:00:00

云计算架构

2010-02-24 15:27:04

ibmdwMashup

2009-07-17 13:49:57

Windows Emb

2018-02-27 15:41:27

IOT语义操作性

2009-02-04 17:11:28

JavaFXJava兼容性

2023-12-27 14:50:10

2010-06-25 15:55:43

NetBeans 6.

2023-06-15 15:40:36

2009-08-03 14:36:08

c#组件

2012-05-15 16:21:25

2015-06-16 09:19:12

OpenStackUnitedStack互操作

2018-03-21 16:38:19

IOT语义API

2021-08-19 14:12:30

物联网数据结构IoT

2020-02-14 08:00:00

WindowsLinuxSamba
点赞
收藏

51CTO技术栈公众号