Dynamic lookup as well as named and optional parameters
greatly improve the experience of interoperating with COM APIs such as the
Office Automation APIs. In order to remove even more of the speed bumps, a
couple of small COM-specific features are also added to C# 4.0.
Many COM methods accept and return variant types, which are
represented in the PIAs as object. In the
vast majority of cases, a programmer calling these methods already knows the
static type of a returned object from context, but explicitly has to perform a
cast on the returned value to make use of that knowledge. These casts are so
common that they constitute a major nuisance.
In order to facilitate a smoother experience, you can now choose
to import these COM APIs in such a way that variants are instead represented
using the type dynamic. In other
words, from your point of view, COM signatures now have occurrences of dynamic instead of object
This means that you can easily access members directly off a
returned object, or you can assign it to a strongly typed local variable
without having to cast. To illustrate, you can now say
excel.Cells[1, 1].Value = "Hello";
((Excel.Range)excel.Cells[1, 1]).Value2 = "Hello";
Excel.Range range = excel.Cells[1, 1];
Excel.Range range = (Excel.Range)excel.Cells[1, 1];
Compiling without PIAs
Primary Interop Assemblies are large .NET assemblies
generated from COM interfaces to facilitate strongly typed interoperability. They
provide great support at design time, where your experience of the interop is
as good as if the types where really defined in .NET. However, at runtime these
large assemblies can easily bloat your program, and also cause versioning
issues because they are distributed independently of your application.
The no-PIA feature allows you to continue to use PIAs at
design time without having them around at runtime. Instead, the C# compiler
will bake the small part of the PIA that a program actually uses directly into
its assembly. At runtime the PIA does not have to be loaded.
Because of a different programming model, many COM APIs
contain a lot of reference parameters. Contrary to refs
in C#, these are typically not meant to mutate a passed-in argument for the subsequent
benefit of the caller, but are simply another way of passing value parameters.
It therefore seems unreasonable that a C# programmer should
have to create temporary variables for all such ref
parameters and pass these by reference. Instead, specifically for COM methods,
the C# compiler will allow you to pass arguments by value to such a method, and
will automatically generate temporary variables to hold the passed-in values,
subsequently discarding these when the call returns. In this way the caller
sees value semantics, and will not experience any side effects, but the called
method still gets a reference.
Download complete features list here: