標籤:
C# 程式設計語言自 2002 年初次發布以來已經有了極大的改善,可以協助程式員編寫更清晰易懂、更容易維護的代碼。這種改善來自於不斷加入的新功能,例如泛型型別、可為空白的實值型別、lambda 運算式、迭代器方法、部分類別以及其他大量有用的語言結構。而且,這些改變還經常伴隨著為 Microsoft .NET Framework 庫提供相應的支援。
C# 4.0 延續了這種不斷提高易用性的趨勢。這款產品大大簡化了許多常見任務,包括泛型型別、傳統的互操作以及處理動態物件模型。本文旨在為深入調查探討這些新功能。我將先介紹泛型方差,然後探討傳統互操作特性和動態互操作特性。
協變與逆變
協變與逆變最好通過樣本來介紹,而最好的樣本就在架構中。在 System.Collections.Generic 中,IEnumerable<T> 和 IEnumerator<T> 分別表示一個包含 T 的序列的對象和一個用來遍曆該序列的列舉程式(或迭代器)。這些介面長期以來承擔了大量繁重的任務,因為它們允許實現 foreach 迴圈構造。在 C# 3.0 中,它們變得更加突出,因為它們在 LINQ 和 LINQ 到對象中起著重要作用:它們是表示序列的 .NET 介面。
因此,假如您有一個類階層,其中包含一個 Employee 類型以及從這個 Employee 類型派生而來的 Manager 類型(畢竟經理也是員工),那麼您認為以下代碼會產生什麼效果?
IEnumerable<Manager> ms = GetManagers();IEnumerable<Employee> es = ms;
看起來好像應該能夠將 Manager 序列當作 Employee 序列。但是在 C# 3.0 中,賦值操作將失敗;編譯器將提示您,沒有相應的轉換功能。畢竟,該版本根本不能理解 IEnumerable<T> 的語義。這可以是任何介面,因此對於任意介面 IFoo<T>,為什麼就能說 IFoo<Manager> 基本上能替代 IFoo<Employee> 呢?
而在 C# 4.0 中,賦值操作是有效,因為 IEnumerable<T> 以及其他幾種介面均發生了變化,這種變化是由 C# 中新增的型別參數協變支援實現的。
IEnumerable<T> 比任意 IFoo<T> 更加特殊,因為儘管初看起來並不明顯,但是使用型別參數 T 的成員(IEnumerable<T> 中的 GetEnumerator 和 IEnumerator<T> 中的 Current 屬性)實際上僅在傳回值的位置使用 T。因此,您只能從序列中擷取 Manager,而絕不能向其中放入 Manager。
相比之下,讓我們看看 List<T>。由於以下原因,用 List<Manager> 來替代 List<Employee> 將是一場災難:
List<Manager> ms = GetManagers();List<Employee> es = ms; // Suppose this were possiblees.Add(new EmployeeWhoIsNotAManager()); // Uh oh
正如這段代碼所示,如果您認為您是在查看 List<Employee>,那您就可以插入任何員工。但實際上正在操作的列表是 List<Manager>,因此插入非 Manager 的員工一定會失敗。如果允許這種操作,就會失去型別安全。List<T> 不能對 T 進行協變。
而 C# 4.0 中有一項新的語言功能,允許定義一些類型(例如新的 IEnumerable<T>),只要正在處理的型別參數之間存在一定的關係,就允許在這些型別參數之間進行轉換。.NET Framework 開發人員編寫 IEnumerable<T> 時就使用了這項特性,他們的代碼類似於下面的代碼(當然經過了簡化):
public interface IEnumerable<out T> { /* ... */ }
請注意修飾型別參數 T 的定義的 out 關鍵字。當編譯器遇到此關鍵字時,會將 T 標記為協變,並檢查介面定義中使用的 T 是否均正常(即,它們是否僅在輸出位置使用,這也就是 out 關鍵字的由來)。
為什麼將這種特性稱為協變呢?通過繪製箭頭,最容易看出原因。為了更形象,還是讓我們使用 Manager 和 Employee 類型。由於這兩個類之間存在繼承關係,從 Manager 到 Employee 之間存在隱式引用轉換。
Manager → Employee
現在,由於 IEnumerable<out T> 中 T 的注釋,從 IEnumerable<Manager> 到 IEnumerable<Employee> 之間也存在隱式引用轉換。這就是 T 注釋的目的:
IEnumerable<Manager> → IEnumerable<Employee>
這被稱為協變,因為兩個樣本中的箭頭都指向相同的方向。我們首先定義兩個類型 Manager 和 Employee。然後利用這兩個類型來定義新類型 IEnumerable<Manager> 和 IEnumerable<Employee>。新類型的轉換方式與舊類型一樣。
當這兩種轉換的方向相反時,即為逆變。您可能已經想到這種情況將發生在僅將型別參數 T 用作輸入時,那您就對了。例如,System 命名空間包含一個名為 IComparable<T> 的介面,該介面有一個名為 CompareTo 的方法:
public interface IComparable<in T> { bool CompareTo(T other); }
如果您有 IComparable<Employee>,則應該能夠將其視為 IComparable<Manager>,因為您能做的唯一操作就是將 Employee 添加到該介面中。由於經理本身就是員工,加入經理應該是可行的,實際上也確實加入成功了。本例使用 in 關鍵字來修飾 T,並且以下方案能夠正確執行:
IComparable<Employee> ec = GetEmployeeComparer();IComparable<Manager> mc = ec;
這稱為逆變,因為這次的兩個箭頭方向相反:
Manager → Employee
IComparable<Manager> ← IComparable<Employee>
到現在為止,可以很容易地總結語言特性:在您定義型別參數時可以添加 in 或 out 關鍵字,從而為您提供額外的自由轉換。不過,還是有一些限制。
首先,這種方式僅適用於泛型介面和委託。您不能以這種方式為類或結構聲明泛型參數。造成這種限制的一個簡單原因是:委託很像只擁有一個方法的介面,而由於欄位的存在,無論如何都不能將類看作某種形式的介面。您可以將泛型類的任何欄位當作既是輸入又是輸出,具體取決於您是對它執行寫入還是讀取操作。如果這些欄位涉及型別參數,則這些參數既不能協變也不能逆變。
其次,如果某個介面或委託具有協變或逆變型別參數,則只有在該介面使用(而不是其定義)中,型別參數是參考型別時,才允許對該類型執行新的轉換。例如,由於 int 是實值型別,因此即使看起來應該能行,但是 IEnumerator<int> 事實上不能轉換為 IEnumerator <object>:
IEnumerator <int> IEnumerator <object>
出現這種行為的原因是轉換必須保留類型的表現形式。如果允許執行 int 到 object 的轉換,就不可能調用結果的 Current 屬性,因為實值型別 int 與對象引用在堆棧中所具有的表現形式是不一樣的。但所有參考型別在堆棧中都具有相同的表現形式,因此只有在型別參數為參考型別時,才能實現這些額外的轉換。
大多數 C# 開發人員很可能會開心地使用這項新的語言功能,因為在使用 .NET Framework 提供的某些類型(IEnumerable<T>、IComparable<T>、Func<T>、Action<T> 等等)時,他們會獲得更多架構類型的轉換,而且編譯器錯誤也會更少。事實上,只要設計的庫包含泛型介面和委託,設計人員就可以根據需要自由使用新的 in 和 out 型別參數,使其使用者能夠更輕鬆地使用他們設計的庫。
另外,此功能需要運行時的支援,但這項支援早就存在了。可是由於沒有什麼語言用到這項支援,它已經沉寂了好幾個版本。同樣,前幾個版本的 C# 允許一些有限的逆變轉換。特別是,它們允許您使用具有相容傳回型別的方法來產生委託。此外,數群組類型始終都是協變的。這些既有的功能與 C# 4.0 中的新功能截然不同,後者實際上是允許您定義自己的類型,使類型中的部分型別參數支援協變和逆變。
動態調度
在 C# 4.0 中的互操作功能方面,我們將首先介紹有可能是最大的變化。
C# 現在支援動態後期綁定。該語言以前始終是強型別的,在 4.0 版中仍將是這樣。Microsoft 認為這會使 C# 快捷易用,適合 .NET 程式員交給它的所有任務。但有時候,您需要與不是基於 .NET 的系統通訊。
通常,至少有兩種方法可以實現此目的。第一種方法是直接將外部模型作為代理匯入到 .NET 中。COM Interop 就是一個這樣的例子。自從最初發布 .NET Framework 以來,它就通過一種名為 TLBIMP 的工具實施了這種策略:該工具可以建立您能夠直接在 C# 中使用的新 .NET 代理類型。
C# 3.0 中附帶的 LINQ-to-SQL 包含一種名為 SQLMETAL 的工具,可以將現有的資料庫匯入到 C# 代理類中,以便與查詢結合使用。您還可以找到一種工具,用於將 Windows Management Instrumentation (WMI) 類匯入到 C# 中。許多技術都允許您編寫 C#(通常帶有特性),然後使用手寫代碼作為外部操作的基礎來執行互操作,這樣的技術包括:LINQ-to-SQL、Windows Communication Foundation (WCF) 和序列化。
第二種方法完全放棄了 C# 類型系統,而將字串和資料嵌入到代碼中。當您編寫代碼來調用 JScript 對象的方法或者在 ADO.NET 應用程式中嵌入 SQL 查詢時,您實際上就採用了這種方法。甚至您使用反射將綁定延遲到運行時(在這種情況下是與 .NET 本身進行互操作),實際上也是採用了這種方法。
C# 中的 dynamic 關鍵字的目的就是處理這些方法所面對的麻煩事。讓我們來舉一個簡單的樣本:反射。通常,使用反射時需要大量樣板基礎結構代碼,例如:
object o = GetObject();Type t = o.GetType();object result = t.InvokeMember("MyMethod", BindingFlags.InvokeMethod, null, o, new object[] { });int i = Convert.ToInt32(result);
有了 dynamic 關鍵字,就不需要按照這種方式使用反射來調用某個對象的 MyMethod 方法,而是可以告訴編譯器:請將 o 視為動態,將所有分析都延遲到運行時。其實現代碼如下所示:
dynamic o = GetObject();int i = o.MyMethod();
此代碼能夠正常使用,並且它用極其簡潔的代碼就完成了同樣的工作。
如果您看看用來支援 JScript 對象操作的 ScriptObject 類,可能會更清楚地認識到這種簡潔的 C# 文法的價值。 該類有一個 InvokeMember 方法擁有較多不同的參數;而在 Silverlight 中,該類卻有一個 Invoke 方法(請注意名稱上的差別)擁有較少的參數。這兩種方法與您在調用 IronPython 或 IronRuby 對象的方法時所需的方法都不相同,與您在調用可能需要互動的任意數量的非 C# 對象的方法時所需的方法也不相同。
除了來自動態語言的對象以外,您還會發現許多本身就是動態且由不同 API 提供支援的資料模型,例如 HTML DOM、System.Xml DOM 和用於 XML 的 XLinq 模型。COM 物件通常都是動態,因此如果能將某些編譯器分析延遲到運行時,就能獲益匪淺。
本質上,C# 4.0 為動態操作提供了一種簡單而又統一的視角。為了充分利用這一點,您要執行的所有操作就是指定給定的值是動態,從而確保對該值執行的所有操作都延遲到運行時進行分析。
在 C# 4.0 中,dynamic 是一種內建類型,用一個偽關鍵字標出。但是請注意,這種 dynamic 與 var 不同。用 var 聲明的變數實際上具有強型別,不過程式員將其留給編譯器判斷罷了。當程式員使用 dynamic 時,編譯器不知道要使用的類型,程式員將這種判斷留給運行時決定。
動態和 DLR
在運行時支援這些動態操作的基礎結構稱為動態語言運行時 (DLR)。這個新的 .NET Framework 4 庫與其他任何託管庫一樣運行於 CLR 之上。它負責在啟動動態操作的語言與實際發生動態操作的對象之間協調每個動態操作。如果動態操作不是由實際發生動態操作的對象處理的,C# 編譯器的運行時組件將會處理綁定。簡單但不完整的體繫結構圖如圖 1 所示。
圖 1 DLR 運行於 CLR 之上
關於動態操作(例如動態方法引動過程)有一件有趣的事,即接收對象在運行時有機會將其本身注入到綁定中,從而能夠完全決定任何給定動態操作的語義。例如,讓我們看一看以下代碼:
dynamic d = new MyDynamicObject();d.Bar("Baz", 3, d);
如果 MyDynamicObject 的定義如下所示,您可以想象一下會發生什麼:
class MyDynamicObject : DynamicObject { public override bool TryInvokeMember( InvokeMemberBinder binder, object[] args, out object result) { Console.WriteLine("Method: {0}", binder.Name); foreach (var arg in args) { Console.WriteLine("Argument: {0}", arg); } result = args[0]; return true; }}
事實上,該代碼會輸出:
Method: BarArgument: BazArgument: 3Argument: MyDynamicObject
通過將 d 聲明為類型 dynamic,使用 MyDynamicObject 執行個體的代碼就能有效地取消對 d 參與的操作進行的編譯時間檢查。使用 dynamic,即表示“我不知道此變數會是什麼類型的,因此我不知道它現在有哪些方法或屬性。編譯器,請讓它們通過編譯,留待運行時真正存在對象時再做判斷。”因此即使編譯器不知道 Bar 調用是什麼意思,也能正確編譯該調用。隨後,在運行時,將由該對象本身來決定 Bar 調用將執行什麼操作。這就是 TryInvokeMember 所知道的處理方式。
現在,假設您使用一個 Python 對象來代替 MyDynamicObject:
dynamic d = GetPythonObject();d.bar("Baz", 3, d);
如果該對象是下面列出的檔案,則該代碼也能正確執行,並且輸出幾乎完全一樣:
def bar(*args): print "Method:", bar.__name__ for x in args: print "Argument:", x
實際上,每次使用 dynamic 值時,編譯器都會產生一些代碼,用來初始化和使用 DLR CallSite。該 CallSite 包含在運行時進行綁定所需的全部資訊,包括方法名稱、額外資料(例如是否在已檢驗上下文中執行操作)以及有關參數及其類型的資訊。
如果您必須維護此代碼,則此代碼完全像上面所示的反射代碼、ScriptObject 代碼或包含 XML 查詢的代碼一樣醜陋。這是 C# 中動態功能的要求,但您沒必要像這樣編寫代碼!
在使用 dynamic 關鍵字時,您的代碼完全可以像您所期望的那樣:像簡單的方法調用、索引器調用、運算子(例如 +)、類型轉換甚至複合運算子(例如 += 或 ++)。您甚至可以在語句中使用 dynamic 值,例如 if(d) 和 foreach(var x in d)。還可以通過 d && ShortCircuited 或 d ??ShortCircuited 等代碼支援短路。
由 DLR 為這類操作提供通用基礎結構的價值在於您不再需要為代碼中使用的每種動態模型處理不同的 API,只需要一個 API 就夠了。而且,您甚至不需要使用它。C# 編譯器會為您使用它,這使您能夠有更多時間來編寫真正需要的代碼。您必須維護的基礎結構代碼越少,意味著您的效率越高。
C# 語言沒有為定義動態對象提供捷徑。C# 中的動態功能僅僅涉及到使用 動態對象。請看以下代碼:
dynamic list = GetDynamicList();dynamic index1 = GetIndex1();dynamic index2 = GetIndex2();string s = list[++index1, index2 + 10].Foo();
此代碼能夠進行編譯,並且包含大量動態操作。首先是 index1 存在動態預先遞增,其次是對 index2 的動態加操作。接著對列表調用了一個動態索引器擷取操作。這些操作所產生的結果又調用了成員 Foo。最後,該運算式的總結果被轉換為 string 並儲存到 s 中。一行代碼中包含五個動態操作,每一個都是在運行時調度的。
每個動態操作的編譯時間類型即為 dynamic 本身,因此“動態”很像是在計算之間流動。即使您沒有多次包含動態運算式,仍然可能會有大量動態操作。這一行代碼中仍然有五個動態操作:
string s = nonDynamicList[++index1, index2 + 10].Foo();
由於兩個索引運算式是動態,因此索引本身也是動態。而由於索引的結果是動態,因此 Foo 調用也是動態。然後,您面臨著將 dynamic 值轉換為 string。這當然也是動態發生的,因為該對象可以是要在面對轉換請求時執行某種特殊計算的動態對象。
請注意,在上一個樣本中,C# 允許從任何動態運算式向任何類型的隱式轉換。最後轉換為 string 就是一個隱式轉換,不需要顯式的類型轉換操作。同樣,任何類型也都可以隱式轉換為 dynamic 類型。
在這種情況下,dynamic 更像一個對象,而且這兩者之間的相似性不僅局限在這些方面。當編譯器發出您的程式集並需要發出 dynamic 變數時,它是通過使用類型對象,然後專門對該對象進行標記,來完成這種操作的。從某種意義上講,dynamic 是一種對象別名,不過是增加了在您使用它時動態解析操作的額外行為而已。
如果您嘗試在兩種泛型型別之間進行轉換,且這兩種類型的唯一差別是 dynamic 和 object,您就會看到這種效果;這樣的轉換總是能夠正確進行的,因為在運行時,List<dynamic> 的執行個體實際上就是 List<object> 的執行個體:
List<dynamic> ld = new List<object>();
如果您嘗試重寫一個在聲明時帶有 object 參數的方法,也可以瞭解 dynamic 和 object 之間的相似性:
class C { public override bool Equals(dynamic obj) { /* ... */ }}
儘管它在您的程式集中會解析為修飾的對象,但我確實喜歡將 dynamic 視為真正的類型,因為它可以提醒您:您使用其他任何類型能夠執行的大部分操作,也可以使用 dynamic 來執行。您可以將其用作型別參數或傳回值。例如,以下函數定義將讓您動態使用函數調用的結果,而不需要將其傳回值儲存到 dynamic 變數中:
public dynamic GetDynamicThing() { /* ... */ }
對於處理和調度 dynamic 的方式,還有許多細節資訊,但是您即使不瞭解這些資訊,也能使用該功能。關鍵的一點是您可以編寫類似於 C# 的代碼,如果您編寫的代碼的任何部分是動態,編譯器就會將其留到運行時處理。
對於動態功能,我要介紹的最後一個主題是:故障。由於編譯器無法檢查您所使用的動態內容是否真的具有名為 Foo 的方法,因此編譯器無法報告錯誤。當然,這並不意味著 Foo 調用在運行時就能正確執行。它有可能正確執行,但也有很多個物件並不具有名為 Foo 的方法。當您的運算式在運行時綁定失敗時,綁定器將盡量為您提供一個異常。在一定程度上,這個異常與您未使用 dynamic 作為開頭時,編譯器提供的異常相似。
請考慮以下代碼:
try { dynamic d = "this is a string"; d.Foo();}catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException e){ Console.WriteLine(e.Message);}
在此,我有一個字串,而字串明顯不會有名為 Foo 的方法。當調用 Foo 的那行代碼執行時,綁定就會失敗,而您將得到 RuntimeBinderException。下面是上一個程式的輸出:
‘string‘ does not contain a definition for ‘Foo‘
這正是 C# 程式員所希望看到的錯誤訊息。
具名引數和選擇性參數
在 C# 的另一項新增功能中,方法現在支援具有預設值的選擇性參數,因此在您調用這樣的方法時,您可以省略這些參數。在下面的 Car 類中,您可以看到其樣本:
class Car { public void Accelerate( double speed, int? gear = null, bool inReverse = false) { /* ... */ }}
您可以按以下方式調用該方法:
Car myCar = new Car();myCar.Accelerate(55);
這種方式與以下代碼等效:
myCar.Accelerate(55, null, false);
由於編譯器將插入您省略的所有預設值,因此這兩段代碼完全相同。
C# 4.0 還允許您在調用方法時通過名稱來指定某些參數。通過這種方法,您可以直接向選擇性參數傳遞實參,而不用向該參數之前的所有參數都傳遞實參。
比如,您希望按相反的順序調用 Accelerate,但您不希望指定 gear 參數。那麼您可以按以下方式調用:
myCar.Accelerate(55, inReverse: true);
這是一種新的 C# 4.0 文法,跟以下代碼是等效的:
myCar.Accelerate(55, null, true);
事實上,無論您調用的方法中的參數是否可選,您都可以在傳遞實參時使用名稱。例如,這兩種調用都是允許的,並且兩者是等效的:
Console.WriteLine(format: "{0:f}", arg0: 6.02214179e23);Console.WriteLine(arg0: 6.02214179e23, format: "{0:f}");
如果調用的方法有大量參數,您甚至可以使用名稱作為代碼中的說明,協助您記住每一個具體的參數。
表面上看起來,選擇性參數和具名引數與互操作功能一點都不像。您在使用這兩種參數時甚至都不會想到互操作。但是,推出這些功能的動機都來自於 Office API。例如,想想 Word 編程以及 Document 介面上簡單的 SaveAs 方法。此方法有 16 個參數,所有參數都是可選的。在前幾個版本的 C# 中,如果您想調用此方法,就必須編寫類似如下的代碼:
Document d = new Document();object filename = "Foo.docx";object missing = Type.Missing;d.SaveAs(ref filename, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);
而現在,您可以編寫如下代碼:
Document d = new Document();d.SaveAs(FileName: "Foo.docx");
我認為,對於任何需要使用類似 API 的程式員來說,這都是一項進步。改善 Office 程式員的生活品質無疑是在語言中添加具名引數和選擇性參數的一項決定性因素。
現在,在編寫 .NET 庫並考慮添加具有選擇性參數的方法時,您將面臨一個選擇:添加選擇性參數,還是像 C# 程式員多年以來所做的那樣引入重載。在 Car.Accelerate 樣本中,後一種決定會使您得到類似如下的類型:
class Car { public void Accelerate(uint speed) { Accelerate(speed, null, false); } public void Accelerate(uint speed, int? gear) { Accelerate(speed, gear, false); } public void Accelerate(uint speed, int? gear, bool inReverse) { /* ... */ }}
為您編寫的庫選擇合適的模型,完全由您自己決定。由於 C# 到目前為止還沒有選擇性參數,.NET Framework(包括 .NET Framework 4)傾向於使用重載。如果您決定混合搭配重載和選擇性參數,C# 重載解析有一些明顯的決定性規則,可在任何環境下決定調用哪一個重載。
帶索引的屬性
C# 4.0 中,有一些較小的語言功能僅在針對 COM Interop API 進行編程時受到支援。上一個樣本中的 Word 互操作就是一個例子。
C# 代碼始終都有一個索引器的概念,您可以將索引器添加到類中,以便在該類的執行個體中有效地重載 [] 運算子。這種索引器也稱為預設索引器,因為它沒有名稱,調用時也不需要名稱。有些 COM API 還具有非預設的索引器,這種索引器不能通過使用 [] 有效地進行調用,而必須指定名稱。此外,您也可以將帶索引的屬性當作能夠接受一些額外參數的屬性。
C# 4.0 在 COM Interop類型上支援帶索引的屬性。您不能在 C# 中定義具有帶索引的屬性的類型,但是只要 COM 類別型具有帶索引的屬性,您就可以使用這種類型。例如,如果考慮 Excel 工作表上的 Range 屬性,則執行此操作的 C# 代碼將如下所示:
using Microsoft.Office.Interop.Excel;class Program { static void Main(string[] args) { Application excel = new Application(); excel.Visible = true; Worksheet ws = excel.Workbooks.Add().Worksheets["Sheet1"]; // Range is an indexed property ws.Range["A1", "C3"].Value = 123; System.Console.ReadLine(); excel.Quit(); }}
在此樣本中,Range[“A1”, “C3”] 不是一個名為 Range 並返回帶索引內容的屬性。它是一個 Range 訪問器調用,並且傳遞了 A1 和 C3。儘管 Value 看起來可能不像一個帶索引的屬性,它實際上還是一個帶索引的屬性!它的所有參數都是可選的,並且因為它是一個帶索引的屬性,所以您可以通過不指定參數來省略這些參數。在語言支援帶索引的屬性之前,您必須編寫如下調用代碼:
ws.get_Range("A1", "C3").Value2 = 123;
此處,加入 Value2 屬性,只是因為帶索引的屬性 Value 在 C# 4.0 以前的版本中不能正確執行。
在 COM 調用點省略 Ref 關鍵字
有些 COM API 在編寫時通過引用傳遞了許多參數,甚至在實現方案不需要寫回這些參數時也是如此。在 Office 套件中,Word 就是一個明顯的例子,其 COM API 都是這麼做的。
當您面對這樣一個庫,並且需要通過引用來傳遞參數時,您就不能再傳遞任何非本地變數或欄位的運算式,這是一個大難題。在 Word SaveAs 樣本中,您可以看到這種情況:只是為了調用 SaveAs 方法,您必須聲明一個局部調用的 filename 和一個局部調用的 missing,因為這兩個參數需要通過引用來傳遞。
Document d = new Document();object filename = "Foo.docx";object missing = Type.Missing;d.SaveAs(ref filename, ref missing, // ...
在下面的新 C# 代碼中,您可能會注意到我不再聲明 filename 局部變數:
d.SaveAs(FileName: "Foo.docx");
這是因為 COM Interop的新的省略 ref 功能。現在,在調用 COM Interop方法時,您可以通過值,而不是通過引用來傳遞任何參數。如果您通過值來傳遞參數,編譯器將代表您臨時建立一個局部變數,然後根據需要為您通過引用傳遞該局部變數。當然,如果方法對參數進行了改變,您就看不出方法調用的效果。如果您希望這樣,請通過引用來傳遞參數。
這應該會使像這樣使用 API 的代碼變得更清晰。
嵌入 COM Interop類型
這更像是 C# 編譯器功能,而不像是 C# 語言功能,但您現在可以使用 COM Interop程式集,而不要求該程式集在運行時必須存在。目的是減輕將 COM Interop程式集與您的應用程式一起部署的負擔。
當 COM Interop在最初版本的 .NET Framework 中引入時,就確立了主要 Interop 組件 (PIA) 的概念。引入此概念,是為瞭解決在組件之間共用 COM 物件的難題。如果您有一些不同的Interop 組件,分別定義了一個 Excel Worksheet,則我們無法在組件之間共用這些 Worksheet,因為它們具有不同的 .NET 類型。PIA 通過只存在一次而解決了這個難題:所有用戶端都使用它,因此 .NET 類型始終是匹配的。
儘管 PIA 在理論上是個好主意,但在實際部署中卻被證明是個大麻煩,因為它只有一份,而有多個應用程式可能會嘗試安裝或卸載它。而由於 PIA 通常很大,事情更複雜了。Office 在預設 Office 安裝方式中並未部署它們,使用者只需通過使用 TLBIMP 來建立自己的Interop 組件,即可輕鬆繞過這一個程式集系統。
因此,現在為了扭轉這種局面,發生了兩件事:
- 對於兩個結構相同且共用相同識別特徵(名稱、GUID 等)的 COM Interop類型,運行時能夠聰明地將其看作同一個 .NET 類型。
- C# 編譯器利用這一點的方式是在編譯時間直接在您自己的程式集中重現互操作類型,因此不再要求在運行時存在該Interop 組件。
由於篇幅所限,我不得不省略一些詳細資料,但即使不瞭解這些資訊,您也應該能夠毫無障礙的使用這個功能,就像動態功能一樣。您通過將引用上的“嵌入式互操作類型”屬性設定為 true,告訴編譯器為您將互操作類型嵌入到 Visual Studio 中。
由於 C# 團隊希望這種方法成為引
.NET Framework 4 中的新 C# 功能