Free-ebooks-library - Bahar Ali Khan

a COM instance, and then use dynamic binding to call members from then on. Of
course, there’s no IntelliSense, and compile-time checks are impossible:
Type excelAppType = Type.GetTypeFromProgID ("Excel.Application", true);
dynamic excel = Activator.CreateInstance (excelAppType);
excel.Visible = true;
dynamic wb = excel.Workbooks.Add();
excel.Cells [1, 1].Value2 = "foo";
(The same thing can be achieved, much more clumsily, with reflection instead of
dynamic binding.)
A variation of this theme is calling a COM component that supports
only IDispatch. Such components are quite rare, however.
Dynamic binding can also be useful (to a lesser extent) in dealing with the COM
variant type. COM API functions are often peppered with this type, which is roughly
equivalent to object in .NET. The runtime maps variant to object prior to C# 4.0,
with the effect that you must explicitly cast return values—as in the following
example:
var excel = new Excel.Application();
excel.Visible = true;
Workbook workBook = excel.Workbooks.Add (System.Reflection.Missing.Value);
var range = (Excel.Range) excel.Cells [1, 1];
range.Font.FontStyle = "Bold";
The fact that some COM methods return variants is often due
to poor design more than to necessity.
From C# 4.0, variant types are instead mapped to dynamic (if Embed Interop Types
is enabled; more on this soon), allowing you to replace the last two lines with this:
excel.Cells [1, 1].Font.FontStyle = "Bold";
The disadvantage of working in this way is that you lose auto-completion, so you
must know that a property called Font happens to exist. For this reason, it’s usually
easier to dynamically assign the result to its known interop type:
Excel.Range range = excel.Cells [1, 1];
range.Font.FontStyle = "Bold";
As you can see, this saves only five characters over the old-fashioned approach!
The mapping of variant to dynamic is the default from Visual Studio 2010, and is a
function of enabling Embed Interop Types on a reference.
974 | Chapter 25: Native and COM Interoperability