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

【独家特稿】这里将为大家介绍C# 4.0当中的COM互操作性以及方差这两个新特性。之前曾报道过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. 
  
  
  
  2. namespace COMInterop 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.    class Program 
    5. 
  
  
  
  5.    { 
    6. 
  
  
  
  6.       static void Main(string[] args) 
    7. 
  
  
  
  7.       { 
    8. 
  
  
  
  8.          Word.Application wordApplication =  
    9. 
  
  
  
  9.             new Word.Application() { Visible = true }; 
    10. 
  
  
  
  10.          object missingValue = System.Reflection.Missing.Value; 
    11. 
  
  
  
  11.          object readOnlyValue = true; 
    12. 
  
  
  
  12.          object fileName = @"C:\\DevX.docx"; 
    13. 
  
  
  
  13.          wordApplication.Documents.Open(ref fileName, ref  
    14. 
  
  
  
  14.             missingValue, ref readOnlyValue, 
    15. 
  
  
  
  15.             ref missingValue, ref missingValue,  
    16. 
  
  
  
  16.             ref missingValue, ref missingValue,  
    17. 
  
  
  
  17.             ref missingValue, ref missingValue, 
    18. 
  
  
  
  18.             ref missingValue, ref missingValue,  
    19. 
  
  
  
  19.            ref missingValue, ref missingValue,  
    20. 
  
  
  
  20.            ref missingValue,ref missingValue); 
    21. 
  
  
  
  21.       } 
    22. 
  
  
  
  22.    } 
    23. 
  
  
  
  23. }
    24.

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

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

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

性能改善

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

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

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

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

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

 
 
 
    
  
  
  
  1. excelObj.Cells[5, 5].Value = "This is sample text";
    2.

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

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

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

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

注意：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. 
  
  
  
  2. { 
    3. 
  
  
  
  3.    IEnumerator GetEnumerator(); 
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5. public interface IEnumerator : IEnumerator 
    6. 
  
  
  
  6. { 
    7. 
  
  
  
  7.   bool MoveNext(); 
    8. 
  
  
  
  8.   T Current { get; } 
    9. 
  
  
  
  9. }
    10.

在c#的早期版本中，IEnumerable不是IEnumerable。注意前面Ienumerator定义中的out参数，它表明普通的T只可以在输出位置，否则编译器就会报告错误，T中的接口是协变的，意味着IEnumerable

也是 IEnumerable用P替换Q所得，因此，一个字符串序列也是一个对象序列，因此下面的语句完全有效：
IEnumerable someObj = new List();

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

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

逆变性

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

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

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

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

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

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

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

分享文章：C#4.0中COM互操作性和方差得到增强
转载源于：http://www.csdahua.cn/qtweb/news35/368535.html

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

广告

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

成都快上网为您推荐相关内容

App设计知识

行业网站建设

四川德阳主机托管　　 　广元双南建站　　 　广安搬家公司　　 　腾讯香港虚拟主机　　 　响应式建站　　 　成都口碑营销公司　　 　香港主机　　 　成都定制网站　　 　微信小程序　　 　绵阳科技城电信IDC机房　　 　成都网站优化　　 　高端网站建设　　 　重庆水土机房托管　　 　seo网络营销推广　　 　一元广告　　 　网站设计制作报价　　 　成都包装设计公司　　 　zaowang.cn　　 　雷运建站　　 　成都路面机械设备