Mohammed Al-Atari

·          Multiline Lambdas: A multiline lambda is a lambda expression that represents a function containing one or more statements. 

·          Sub Lambdas: Just as the “Function” keyword can be used to create a multiline lambda that returns a value, the “Sub” keyword can be used to create a multiline lambda that does not return a value

·          Single-line Sub Lambdas: Visual Basic 9.0 only supported lambdas that were a single expression that returned a value; for example, the following line was an error:

With Visual Basic 10.0, lambdas can now contain expressions that do not return a value:

·          Implicit Line Continuation: The underscore character is used in Visual Basic to indicate that the current logical line is being split up over one or more physical lines.  Visual Basic 10.0 removes the requirement for an underscore to be present after certain tokens where its presence can be inferred (i.e. the line continuation character becomes “implicit”).  While the need to use underscore has not been entirely removed from the language, the intention is that developers will not have to use it in the vast majority of lines they write.

At a high level, the line continuation character is implicit in the following situations:

1.      After an attribute

2.      After a comma

3.      After a dot (i.e. for method invocation)

4.      After a binary operator

5.      After a LINQ query clause

6.      After a (, {, or <%=

7.      Before a ), }, or %>

The following code demonstrates some of the places where implicit line continuation can be used:

·          Auto-implemented Properties: Developers often need to create simple entity classes or containers for data, in which the properties defined follow a very simple structure:

Auto-implemented properties provide a simple one-line way of expressing this concept  :

In this case the compiler will generate a backing field with the same name as the property, but with a preceding underscore.  It will also fill in the property’s getter and setter.

Initializers can be used to give an auto-implemented property a default value (which gets set in the class’ constructor):

Auto-implemented properties cannot have parameters, nor can they be declared ReadOnly or WriteOnly.

·          Collection Initializers: Collection initializers provide a way to initialize a collection type and provide it with a series of default values within a single expression.  For example:

Each element after the “From” keyword will be passed to the Add method on the type:   

      Similarly, Dictionaries can also be initialized this way:

When the elements after “From” are nested, the compiler will “unpack” the elements inside each set of brace and pass them sequentially to a single Add call:    

Developers are free to provide their own implementation of Add, either as an instance method on the type or through an extension method:

·          Array Literals: Array literals provide a compact syntax for declaring an array whose type is inferred by the compiler.

Nested array literals can be used to produce multidimensional arrays:

·          Nullable Optional Parameters: Optional parameters can now be typed as Nullable and initialized to a default value:

·          Generic Variance: (VB and C# are introducing this feature simultaneously, and the implementations are practically identical.  The following section is adapted from Mads Torgersen’s excellent write-up in the equivalent document for C#.) An aspect of generics that often comes across as surprising is that the following is illegal:

The second assignment is disallowed because strings does not have the same element type as objects. There is a perfectly good reason for this. If it were allowed you could write:

This would be allowing an Integer to be inserted into a list of Strings and subsequently extracted as a String, which would be a breach of type safety.

However, there are certain interfaces where the above cannot occur, notably where there is no way to insert an object into the collection.  One such interface is IEnumerable(Of T).  If instead you say:

There is no way we can put the wrong kind of thing into strings through objects, because objects does not have a method that takes an element in.  Variance is about allowing assignments such as this in cases where it is safe. The result is that a lot of situations that were previously surprising now just work.

·          Covariance: In .NET 4.0 the IEnumerable(Of T) interface will be declared in the following way:

The Out in these declarations signifies that T can only occur in output position in the interface – the compiler will complain otherwise. In return for this restriction, the interface becomes “covariant” in T, which means that an IEnumerable(Of A) is considered an IEnumerable(Of B) if A has a reference conversion to B.

As a result, any sequence of strings is also e.g. a sequence of objects.  There are many places in LINQ where this can be useful, for example:

This would previously have been disallowed, and you would have had to do some cumbersome wrapping to get the two sequences to have the same element type.

·          Contravariance: Type parameters can also have an In modifier, restricting them to occur only in input positions.  An example is IComparer(Of T):

The somewhat baffling result is that an IComparer(Of Object) can in fact be considered an IComparer(Of String)! It makes sense when you think about it: If a comparer can compare any two objects, it can certainly also compare two strings. This property is referred to as contravariance.

A generic type can have both In and Out modifiers on its type parameters, as is the case with the generic Func delegate types:

Obviously the argument would only ever come In, and the result would only ever come Out.  Therefore a Func(Of Object, String) can in fact be used as a Func(Of String, Object).

·          Limitations: Variant type parameters can only be declared on interfaces and delegate types, due to a restriction in the CLR.  Variance only applies when there is a reference conversion between the type arguments.  For instance, an IEnumerable(Of Integer) is not an IEnumerable(Of Object), because the conversion from Integer to Object is a boxing conversion, not a reference conversion.

Also please note that the CTP does not contain the new versions of the .NET types mentioned above. In order to experiment with variance you have to declare your own variant interfaces and delegate types.

·          Interop with Dynamic Languages: Historically Visual Basic has been a language that provides both the safety and performance of static typing along with the flexibility of dynamic typing.  The Dynamic Language Runtime (DLR) makes it much easier for dynamic languages to interoperate with each other in such a way that each object maintains the semantics from its original language. 

Over the past few years, there has been renewed developer interest in dynamic languages (such as Python/Ruby) and their accompanying libraries/frameworks.  These languages and frameworks can use the DLR’s IDynamicObject interface to define the meanings of dynamic operations, or in the case of an API to allow direct access to an object’s properties through property syntax (a good example of this is the HTML DOM in Silverlight).

Latebinding will continue to work the same way it always has in Visual Basic, but the latebinder itself will be updated to recognize when an object implements the IDynamicObject interface.  This will allow Visual Basic developers to be able to fully interoperate with dynamic languages such as IronPython and IronRuby, as well as APIs that implement IDynamicObject

For example, the following code calls a method defined in the Python library “random.py”:

·          Compiling without PIAs: Using .NET to program against the Microsoft Office Object Model requires the use of Primary Interop Assemblies (PIAs), which must be deployed to the end-user’s machine.  These assemblies are often very large, so deploying them can often be a nuisance.

Visual Basic 10.0 will allow these applications to be deployed without requiring PIAs to exist on the user’s machine.  It does this by generating “local types” that perform the interop calls to the COM library directly.  These types are annotated by the compiler in such a way that the Common Language Runtime (CLR) can unify these types across assemblies.  The compiler will not copy every type in the PIA into your assembly, just the ones you actually use.