The Visual Basic Team : Jonathan Aneja

Hidden Gems in VB2010 – Serializing Objects that Raise Events (Jonathan Aneja)

VBTeam — Tue, 15 Dec 2009 01:21:00 GMT

By now you've likely heard about the major new features coming in VB 2010, but there's also a number of smaller additions in the language and IDE that might not be as readily noticeable. "Hidden Gems" will be a multi-part series where we'll explore some of these smaller enhancements. First up - serialization!

Let’s say you have a simple entity class that you need to serialize and send over the wire. This class implements INotifyPropertyChanged which contains an event. When attempting to serialize an instance of this class, if the delegate which backs the event has its Target property referencing an Object which is not serializable, then the entity class itself can no longer be serialized. For example, if a Form was handling the event raised from this class, the class can no longer be serialized.

In C# the solution is simple – just use a field attribute target to tell the serializer not to attempt to serialize the delegate and any objects it references:

[field: NonSerialized]

public event PropertyChangedEventHandler PropertyChanged;

VB doesn’t support attribute targets for fields though, so the way to work around this is to use a custom event:

<Serializable()>

Public Class Customer

Implements INotifyPropertyChanged

<NonSerialized()>

Private _PropertyChanged As PropertyChangedEventHandler

Public Custom Event PropertyChanged As PropertyChangedEventHandler _

Implements INotifyPropertyChanged.PropertyChanged

AddHandler(ByVal value As PropertyChangedEventHandler)

_PropertyChanged = CType([Delegate].Combine(_PropertyChanged,

value), PropertyChangedEventHandler)

End AddHandler

RemoveHandler(ByVal value As PropertyChangedEventHandler)

_PropertyChanged = CType([Delegate].Remove(_PropertyChanged,

value), PropertyChangedEventHandler)

End RemoveHandler

RaiseEvent(ByVal sender As Object, ByVal e As PropertyChangedEventArgs)

If _PropertyChanged IsNot Nothing Then

_PropertyChanged.Invoke(sender, e)

End If

End RaiseEvent

End Event

...

End Class

(For a more thorough implementation see Rocky’s excellent blog entry). That’s a lot of code to write though – basically you’re having to take control of the backing field yourself just to apply the attribute manually.

How does VB2010 help?

We now allow the NonSerialized attribute to be placed on an Event. The compiler will then:

1. Suppress the error that says “this attribute cannot be used on this type of declaration”

2. Apply the NonSerialized attribute to the event’s backing field.

As a result you’ll be able to type the following in VB 2010 (try it, it works in Beta2!):

<NonSerialized()>

Event PropertyChanged As PropertyChangedEventHandler

Spot the Bug! – The Key to using Anonymous Types (Jonathan Aneja)

VBTeam — Tue, 17 Nov 2009 07:54:00 GMT

This one’s going to be long, but for those of you who’ve felt the first 3 in this series were too easy I promise this one’s tougher J.

Let’s say you want to list all the customers from a table in a ComboBox, and update the UI based on which one is selected. To do this we’ll need to bring back two fields from the database – the customer’s name and the customer’s ID. When a customer is selected we want the ComboBox’s SelectedValue property to equal the customer’s ID.

Here’s some quick code that gets us up and running (using Northwind and LINQ to SQL):

Dim db As New NorthwindDataContext

Dim query = From row In db.Customers _

Select row.CompanyName, row.CustomerID

ComboBox1.DataSource = query.ToList()

ComboBox1.DisplayMember = "CompanyName"

ComboBox1.ValueMember = "CustomerID"

But now let’s say your boss looks at the app and says “I want you to add an ‘All Customers’ option as the first item in the list.” How would you do that? You’d need to insert an anonymous type into an existing sequence of anonymous types, which is tricky given that you can never actually use the type’s name.

Thankfully there’s a trick that uses generic parameter inference that allows us to do this (it relies on the fact that the compiler will share (or “unify”) the definition of multiple anonymous types when they have the same number of members, in the same order, of the same type, with the same names, and the same mutability):

Dim db As New NorthwindDataContext

Dim query = From row In db.Customers _

Select row.CompanyName, row.CustomerID

Dim allOption = New With {.CompanyName = "All Customers", _

.CustomerID = "-1"}

ComboBox1.DataSource = AddOptionForAll(query, allOption).ToList()

ComboBox1.DisplayMember = "CompanyName"

ComboBox1.ValueMember = "CustomerID"

...

Function AddOptionForAll(Of T)(ByVal sequence As IEnumerable(Of T), _

ByVal allOption As T) As IEnumerable(Of T)

'wrap individual element in an array and then union the two sequences

Return (New T() {allOption}).Union(sequence)

End Function

As long as we have an anonymous type that’s compatible with the anonymous type that the query generated, the compiler will determine that sequence and allOption are actually the same type and this should work fine.

Ok so let’s get to the bug – well in this case spotting it is pretty simple (it doesn’t compile J), but fixing it is tricky (though I’ve already given two pretty big hints). Here’s the text of the compiler error (it’s on the line that calls AddOptionForAll):

Data type(s) of the type parameter(s) in method 'Public Function AddOptionForAll(Of T)(sequence As System.Collections.Generic.IEnumerable(Of T), allOption As T) As System.Collections.Generic.IEnumerable(Of T)' cannot be inferred from these arguments because they do not convert to the same type. Specifying the data type(s) explicitly might correct this error.

What’s wrong and how do we fix it?

Answer: We actually told the compiler to generate two different anonymous type definitions, and thus it can’t unify them because the types really are different.

From earlier: “…the compiler will share (or “unify”) the definition of multiple anonymous types when they have the same number of members, in the same order, with the same names, and the same mutability”

The anonymous type that the query generates will have ReadOnly properties, whereas the anonymous type that we generated (allOption) will have Read/Write properties. The fix is to allOption immutable so that its structure will match the result of the query:

Dim allOption = New With {Key .CompanyName = "All Customers", _

Key .CustomerID = "-1"}

The “Key” modifier tells the compiler to make those properties ReadOnly and to override Equals and GetHashCode such that they only consider “Key” properties when deciding if two instances of the same anonymous type are equal. (the other hint was in the title J). For the query above, the compiler automatically inserts the “Key” modifier - i.e. what we wrote is exactly equivalent to this:

Dim query = From row In db.Customers _

Select New With {Key row.CompanyName, Key row.CustomerID}

So with a simple fix to the allOption line we’re now using the same anonymous type definition and everything works fine.

VB’s anonymous type syntax is very flexible and provides three different options: immutable, fully mutable, or partially mutable (i.e. some fields are ReadOnly while others are not). Even for a simple scenario like adding an option to a list, the better you understand how things work under the covers the easier it’ll be to debug problems later J.

Spot the Bug! – Is it in VB or XAML? (Jonathan Aneja)

VBTeam — Fri, 13 Nov 2009 03:39:00 GMT

What’s wrong with the following WPF code?

Class Window1

Sub OK_Click(sender As Object, e As RoutedEventArgs) Handles OK.Click

MsgBox("Button Clicked")

End Sub

End Class

<Window x:Class="Window1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="Window1" Height="300" Width="300">

<Grid>

</Grid>

</Window>

Answer: The message box will be displayed twice! To understand why, open up the project in Reflector, and in the System_Windows_Mark_IComponentConnector_Connect method you’ll see these two lines:

    Me.OK = DirectCast(target, Button)

    AddHandler Me.OK.Click, New RoutedEventHandler(AddressOf Me.OK_Click)

Ok so we’re adding one handler here, but click the link to navigate to “OK”. You’ll see this is actually a property of type Button (that’s what the compiler does for WithEvents/Handles – the full story of how WithEvents works is its own blog entry…). In the Setter you’ll see this code:

    If (Not Me._OK Is Nothing) Then

        AddHandler Me._OK.Click, handler

    End If

So now we can clearly see there’s two AddHandler calls and thus the event gets handled multiple times by the same method (which is perfectly legal). One of them came from Handles OKButton.Click, and the other came from Click="OK_Click".

The key thing to realize is that if you wire up the eventhandler in XAML, don’t wire it up in code using Handles (and vice-versa). Thankfully in this scenario it’s obvious that there’s a problem because there’s a message box, but if the eventhandler was doing something more subtle (such as incrementing a counter or modifying some other state), this can lead to hard-to-diagnose bugs.

Spot the Bug! – Much ado about Nothing… Part 2! (Jonathan Aneja)

VBTeam — Fri, 06 Nov 2009 07:46:00 GMT

In yesterday’s post we saw that the use of the wrong comparison operator with Nothing in an If block can lead to surprising results. Let’s look at a slightly different case today:

Dim x As Integer = Nothing

If x = Nothing Then

MsgBox("A true statement - we land here")

Else

MsgBox("The statement is a lie - we land here")

End If

What gets printed? If the code is intended to print “A true statement…”, is there actually a bug in this code?

Answer: The code is correct according to its “specification” (I’m using the term loosely here J), so from a technical point of view there is no bug here. However, from a code readability and maintenance point of view, I’d argue that there is a bug.

The Nothing literal in VB means “default value for this type”, and for an Integer that would be 0. So the code above is exactly equivalent to this:

Dim x As Integer = 0

If x = 0 Then

MsgBox("A true statement - we land here")

Else

MsgBox("The statement is a lie - we land here")

End If

Now that’s way more readable than the version above, and dramatically reduces the potential for confusion. In general*, if you ever find yourself writing “= Nothing” in a conditional expression, you should either be changing the = to “Is” (as we saw yesterday), or you should change Nothing to the actual default value if possible.

The next post will have a real bug, I promise J

*Yes, there may be cases such as structure/generics/overloaded operators where you actually would want to say “= Nothing” – my point is that if you’re going to do this make sure you know what you’re doing, and insert a comment so that those reading your code also know what you’re doing J.

Spot the Bug! – Much Ado about Nothing… (Jonathan Aneja)

VBTeam — Wed, 04 Nov 2009 02:32:00 GMT

Microsoft has this neat mailing list called “Spot the Bug” where developers can send interesting snippets of code that look correct but actually have subtle bugs in them. The puzzles are a lot of fun and I’ve always thought it’d be a fun thing to try here on the team blog. Over the past year or so I’ve been keeping a list of interesting bug reports and emails where people have been tripped up by some of VB’s hidden subtleties (though admittedly many of these could apply to C# as well).

The format’s gonna be a bit of an experiment – let me know if you prefer to see the answer in the same post or posted a day later. Alright let’s get started…

Spot the Bug:

The following code is intended to print “Yes” – will it?

Dim x As Integer? = Nothing

If x = Nothing Then

MsgBox("Yes: x contains null")

Else

MsgBox("No: x does not contain null, and has a real value")

End If

Answer: No! We’re using the equality operator to compare a nullable integer with Nothing – this results in null propagation, i.e. the result of the expression is Nothing. An If-statement attempts to convert its condition to a Boolean, so basically we’re left with this:

If Nothing Then

Else

'Obviously we'll always land here

End If

This can be really surprising when working with nullables, so we’ve decided to add a warning for this case in VB10:

The warning explains the fix – use “Is” instead of = to avoid the null propagation and get the semantics you expect:

Dim x As Integer? = Nothing

If x Is Nothing Then

MsgBox("Yes: x contains null")

Else

MsgBox("No: x does not contain null, and has a real value")

End If

Check back for a similar case but with a bit of a twist tomorrow...

Properties vs Fields – Why Does it Matter? (Jonathan Aneja)

VBTeam — Sat, 05 Sep 2009 00:01:47 GMT

The other day I got an email from a developer asking an interesting question about VB10’s Auto-implemented Properties feature.

“I am, however, somewhat confused regarding the properties feature you mentioned - i.e. turning 11 lines of get/set/backing variable into one line. Wouldn't this be exactly the same as the existing functionality of creating a public variable? I see no benefit for using a property in this case, except perhaps for the sake of what some would consider best practice.”

On the surface there doesn’t seem to be a big difference between this:

Public Property Name() As String

And this:

Public Name() As String

Clearly both will expose an object’s state to the outside world, and can be read/modified using the exact same syntax. Which then begs the question, why would I ever use a property if I have no special logic in the Getter/Setter?

Let’s consider some reasons:

1. Fields can’t be used in Interfaces

You can’t enforce the existence of a field in an object’s public contract through an interface. For properties though it works fine.

2. Validation

While your application currently may not require any validation logic to set a particular value, changing business requirements may require inserting this logic later. At that point changing a field to a property is a breaking change for consumers of your API. (For example if someone was inspecting your class via reflection).

3. Binary Serialization

Changing a field to a property is a breaking change if you’re using binary serialization. Incidentally, this is one of the reasons VB10’s auto-implemented properties have a “bindable” backing field (i.e. you can express the name of the backing field in code) – that way, if you change an auto-implemented property to an expanded property, you can still maintain serialization compatibility by keeping the backing field name the same (in C# you’re forced to change it because it generates backing fields with unbindable names).

4. A lot of the .NET databinding infrastructure binds to properties but not fields

I’ve heard arguments on both sides as to whether or not that’s a good thing, but the reality is that’s the way it works right now.

5. Exposing a public field is an FxCop violation

For many of the reasons listed above :)

One argument I’ve heard for using fields over properties is that “fields are faster”, but for trivial properties that’s actually not true, as the CLR’s Just-In-Time (JIT) compiler will inline the property access and generate code that’s as efficient as accessing a field directly.

For these reasons and more, in most cases you’re better off using a property rather than exposing a public field. Thankfully VB10 will make this a lot easier :)

Dynamic Searching using LINQ - Dataset + Joins

VBTeam — Sat, 11 Jul 2009 03:22:00 GMT

About two years ago I posted some code that shows how to dynamically construct LINQ queries at runtime. On average there's a couple questions per month about trying it in some edge case, and usually the support already exists within the API. Recently though someone posted a question that has to do with Datasets and Joins that raised some interesting issues:

I have a dataset with two datatables (One Loaded From A CSV file) and (the other loaded from a query) what I would like to be able to do is set the criteria (i.e dtCSV.Field1=dtQuery.Field7 AND (dtCSV.Field5 != dtQuery.Field4 or dtCSV.Field5 != dtQuery.Field9)

Returning dtQuery.Field1, dtCSV.Field5

Previously the API supported conditions of the form "object.property=value", but here we have something of the form "object1.property = object2.property". It's still a completely valid expression, but it means the API will need to generate a different expression tree.

Let's walk through how you can add this support to the API:

1. At the end of Module DynamicQuery add the following extension method:

'Extension method that can be called off any type that implements IEnumerable(Of T),

'which constructs a Condition with T as the element type and compares one property (or field) with another

<Extension(), EditorBrowsable(EditorBrowsableState.Always)> _

Public Function CreateMutliColumnCondition(Of T)(ByVal dataSource As IEnumerable(Of T), _

ByVal propName As String, _

ByVal condType As condition.Compare, _

ByVal propName2 As String) As Condition(Of T)

Return Condition.CreateMutliColumn(dataSource, propName, condType, propName2)

End Function

2. Add this method to the Condition class:

'Constructs a Condition with T as the element type that compares one field/property with another

Public Shared Function CreateMutliColumn(Of T)(ByVal dataSource As IEnumerable(Of T), _

ByVal propertyName As String, _

ByVal condType As Compare, _

ByVal propertyName2 As String) As Condition(Of T)

Return New Condition(Of T)(propertyName, condType, propertyName2)

End Function

3. Add the following code to the Condition(Of T) class:

'Returns a MemberExpression for a property or field access. Also handles nesting scenarios

Private Function GetPropertyExpression(ByVal propName As String, ByVal paramExpr As ParameterExpression) As MemberExpression

'Split the string to handle nested property access

Dim s = propName.Split("."c)

'Get the PropertyInfo instance for propName

Dim pInfo = GetType(T).GetProperty(s(0))

Dim callExpr = Expression.MakeMemberAccess(paramExpr, pInfo)

'For each member specified, construct the additional MemberAccessExpression

'For example, if the user says "myCustomer.Order.OrderID = 4" we need an

'additional MemberAccessExpression for "Order.OrderID = 4"

For i = 1 To UBound(s)

pInfo = pInfo.PropertyType.GetProperty(s(i))

callExpr = Expression.MakeMemberAccess(callExpr, pInfo)

Return callExpr

End Function

Friend Sub New(ByVal propName As String, ByVal condType As Compare, ByVal propName2 As String)

Dim paramExpr = GetParamInstance(GetType(T))

Dim b As Expression = CombineExpression(GetPropertyExpression(propName, paramExpr), _

condType, _

GetPropertyExpression(propName2, paramExpr))

LambdaExpr = Expression.Lambda(Of Func(Of T, Boolean))(b, New ParameterExpression() {paramExpr})

'Compile the lambda expression into a delegate

del = DirectCast(LambdaExpr.Compile(), Func(Of T, Boolean))

End Sub

4. (optionally) the old constructor in this method should be refactored to use the helper method we introduced in #3.

Friend Sub New(ByVal propName As String, ByVal condType As Compare, ByVal value As Object, ByVal valueType As Type)

Dim paramExpr = GetParamInstance(GetType(T))

Dim callExpr = GetPropertyExpression(propName, paramExpr)

'ConstantExpression representing the value on the left side of the operator

Dim valueExpr = Expression.Constant(value, valueType)

Dim b As Expression = CombineExpression(callExpr, condType, valueExpr)

LambdaExpr = Expression.Lambda(Of Func(Of T, Boolean))(b, New ParameterExpression() {paramExpr})

'Compile the lambda expression into a delegate

del = DirectCast(LambdaExpr.Compile(), Func(Of T, Boolean))

End Sub

Now that the API supports it, we can do joins against Datasets:

'The code in this method is equivalent to the following query, but constructed dynamically

'Dim filteredQuery = From csvRow In dtCSV _

' Join orderRow In dtOrders On csvRow.CustomerID Equals orderRow.CustomerID

Dim dtCSV As New myDataset.dtCSVDataTable

dtCSV.Rows.Add(1, "Redmond")

dtCSV.Rows.Add(2, "Toronto")

dtCSV.Rows.Add(3, "Seattle")

Dim dtOrders As New myDataset.dtOrdersDataTable

dtOrders.Rows.Add(10001, 1)

dtOrders.Rows.Add(10002, 3)

dtOrders.Rows.Add(10003, 4)

dtOrders.Rows.Add(10004, 2)

Dim query = From csvRow In dtCSV _

From orderRow In dtOrders

Dim c = query.CreateMutliColumnCondition("csvRow.CustomerID", Compare.Equal, "orderRow.CustomerID")

Dim filteredQuery = query.Where(c)

DataGridView1.DataSource = (From row In filteredQuery _

Select row.orderRow.OrderID, row.csvRow.CustomerID, row.csvRow.City).ToList()

The key line here is this one:

Dim c = query.CreateMutliColumnCondition("csvRow.CustomerID", Compare.Equal, "orderRow.CustomerID")

Instead of comparing a column to a value we can now compare one column to another (either in the same table or in a different table).

<geeky overload resolution details>

Why did I name the method CreateMultiColumnCondition instead of just adding another overload called CreateCondition? To avoid introducing a breaking change! If you had code that called CreateCondition with the last parameter as a String, the compiler would infer the type parameter at that position to be String. But now with a new overload that also has a parameter of type String in that position, the compiler would now choose the new overload because that method is "less generic" (i.e. a closer match).

I don't like the idea of having to think through advanced overload resolution details to figure out which method will actually get called, so it seemed easier to just rename the method :)

</geeky>

A better (and likely more performant) implementation would actually introduce an overload of Join similar to this one for Where:

'Filters an IEnumerable(Of T) according to the specified condition

<Extension()> _

Public Function Where(Of T)(ByVal source As IEnumerable(Of T), _

ByVal condition As Condition(Of T)) As IEnumerable(Of T)

Return source.Where(condition.del)

End Function

This would involve a bit more work in the API though as the Join method takes 3 delegates rather than 1. (so Condition(Of T) would have to generate 3 smaller trees rather than one big one). It's already almost 6 on a Friday though and I'm lazy, so this is left as an exercise to the reader :)

Full VS2008 .sln is attached.

Jonathan

TechEd Video: Future Directions for Visual Basic, by Anders Hejlsberg and Jonathan Aneja

VBTeam — Sat, 20 Jun 2009 18:35:00 GMT

As part of the new VB/C# co-evolution strategy, Visual Studio Technical Fellow Anders Hejlsberg has broadened his role. In addition to being Chief Architect for C#, he now sets the direction for both the VB.NET and C# languages.

At TechEd, Anders participated in both the VB.NET and C# language presentations. In watching these sessions, you can see that the future trends and directions for the VB.NET and C# languages are now the same.

TechEd NA 2009 Session Video: "Future Directions for Visual Basic" by Anders Hejlsberg and Jonathan Aneja

In this talk, we discuss the future direction of the Visual Basic language both in the near and long term. Exciting features from the next release are demonstrated and discussed, including extensions to LINQ support, syntax simplifications, and improvements to the IDE. Larger trends that are likely to deeply influence the direction of the language are also covered, including dynamic binding, meta-programming, and scripting. Finally, we discuss how all these tie together into the roadmap for Visual Basic going forward.

The C# TechEd US video is not publicly available. For the corresponding C# presentation, please watch the following from PDC:

PDC 2008 Session Video: "The Future of C#" by Anders Hejlsberg

In this talk Microsoft Technical fellow and C# Chief Architect Anders Hejlsberg outlines the future of C#. He describes the many forces that influence and shape the future of programming languages and explain how they fit into C#.

TechEd North America, here we come! (Lisa Feigenbaum)

VBTeam — Fri, 01 May 2009 06:05:00 GMT

TechEd North America 2009 is right around the corner. For those of you attending, we look forward to spending time with you at the VB.NET sessions and Technical Learning Center (a.k.a. booth). I've pasted the VB.NET session list below.

DTL04-INT Strategies to Upgrade Your Microsoft Visual Basic 6 Assets to Microsoft .NET
- Mon 5/11 | 1:00 PM-2:15 PM | Blue Theater 2
- Presenter: Rob Windsor
DTL315 Getting the Most from Lambda Expressions
- Mon 5/11 | 2:45 PM-4:00 PM | Room 402
- Presenter: Deborah Kurata
DTL321 Microsoft Visual Basic IDE Tips and Tricks
- Tue 5/12 | 1:00 PM-2:15 PM | Theatre (Room 411)
- Presenter: Dustin Campbell
DTL336 Future Directions for Visual Basic
- Wed 5/13 | 8:30 AM-9:45 AM | Room 152
- Presenter(s): Anders Hejlsberg, Jonathan Aneja
DTL402 How LINQ Works: A Deep Dive into the Microsoft Visual Basic and C# Implementations
- Thu 5/14 | 2:45 PM-4:00 PM | Room 515B
- Presenter: Jonathan Aneja

See you in LA!

Spain User Group Tour: All Good Things Must Come to An End (Lisa Feigenbaum)

VBTeam — Tue, 25 Nov 2008 23:43:00 GMT

After three and a half days visiting user groups through Spain, Jon and I have flown back to the US. We got to meet some great people and had lots of fun talking about VB. The slide decks that we used on the trip are attached at the end of this post.

PPT: Deep Dive on VB 9.0 (link to be added shortly)
PPT: Visual Basic IDE Tips and Tricks

User group meeting in Valencia:

User group meeting in Alicante:

Final pic with our host Pep Lluis after the user group meeting in Madrid:

Visual Basic en España (Lisa Feigenbaum)

VBTeam — Tue, 18 Nov 2008 02:04:00 GMT

This week Jonathan Aneja and I are traveling from city to city, and presenting to VB.Net user groups in Spain. We began the tour in Barcelona where we were speaking at TechEd EMEA, and will finish in Madrid. VB MVP Pep Lluis Blano organized the entire itinerary!

Here are the topics for the presentations:

IDE: 2005, 2008, 2010
Language: LINQ, VB XML, VB 9, VB 10
VB6: Interop Forms Toolkit

The schedule is below. Each meeting is 3hrs. Come join us if you can!

Monday 11/17/2008, 9:30am: Barcelona, Igualada, and Vic groups combined
Monday 11/17/2008, 4:00pm: Tarragona user group
Tuesday 11/18/2008, 4:00pm: Valencia user group
Wednesday 11/19/2008, 9:30am: Alicante user group
Thursday 11/20/2008, 9:30am: Madrid user group

Read on for the invitation and more details en español...

VS/VB Spanish Tour 2008

Un encuentro sin duda esperado. Esta tercera semana de noviembre y una vez finalizado el TechEd Europeo, nos complace anunciar la visita de los equipos de producto de Visual Studio y Visual Basic.

Como parte de las actividades propuestas por los grupos de desarrolladores españoles, esta cita viene a completar y reforzar el compromiso de los mismos en pro de compartir la experiencia en vivo en su faceta mas divulgativa, con los avances y apuestas tecnológicas más recientes impartidas directamente por sus principales protagonistas en los equipos de desarrollo de Microsoft en Redmond.

Durante cuatro días tenemos la oportunidad de unirnos a un tour relámpago recorriendo Barcelona (Vic/Igualada), Tarragona, Valencia, Alicante (Albacete/Murcia) para llegar finalmente a Madrid.

Serán eventos eminentemente técnicos, impartidos en Ingles, divididos en dos sesiones con una duración total de 3 horas. En cada sesión intentaremos bordar lo más relevante del IDE de Visual Studio desde su versión 2005 sin obviar lo que ya se cuece para la versión del 2010, intentando enfocar en todo momento el contenido a su vertiente más práctica. Finalmente podremos profundizar en el lenguaje con los aspectos más interesantes y nuevas características del Visual Basic y su compilador.

Tampoco debemos olvidarnos de la gran oportunidad de interactuar con nuestras opiniones e inquietudes llegando realmente a las personas que están definiendo el producto. Como todas las actividades realizadas por los grupos de desarrolladores, la asistencia es gratuita aunque por características de aforo de las salas, las plazas son limitadas. Si eres programador en C#, este evento también es interesante para ti, puesto que aparte del IDE se comparten muchísimas similitudes con Visual Basic, al fin y al cabo en tono de humor… será una buena oportunidad para olvidarte durante un par de horas del punto y coma.

En resumen una gran cita para todos los que nos relacionamos con esta gran comunidad.

Esta es la hoja de ruta:

Lunes : 17.11.2008

Mañana : 09:30-12:30 Grupos de Barcelona/Igualada/Vic

Tarde : 16:00-19:00 Grupo de Tarragona

Martes: 18.11.2008

Tarde : 16:00-19:00 Grupo de Valencia

Miércoles: 19.11.2008

Mañana: 09:30-12:30 Grupo de Alicante

Jueves: 20.11.2008

Mañana: 09:30-12:30 Grupo de Madrid

Los “Speakers”

Lisa Feigenbaum

Lisa es Program Manager del Editor de Visual Basic. Su equipo es el responsable de algunas de las características de Visual Studio que utilizamos constantemente cada día, principalmente: la IntelliSense, la corrección de errores los snippets de codigo, formateos, renombrado de simbólicos, etc. Es miembro del equipo de Visual Basic desde el año 2004, después de licenciarse en la universidad de Harvard en la especialidad de matemáticas aplicadas.

Jonathan Aneja

Jonathan es Program Manager en el equipo de VB en Redmond. Principalmente trabajando en la parte del compilador que corresponde a LINQ, así mismo ha colaborado en proyectos como el “Interop Forms Toolkit”. Se inicio como ISV y posteriormente se unió al equipo de VB a principios del 2006. Sin duda es un convencido de las magnificas facilidades que VB aporta al desarrollador, y evidentemente al ser un apasionado del lenguaje convierte en un placer poder trabajar cada día en él.

El temario:

Se dividirá en dos sesiones de 1h15Min y una pausa de unos de 30mins para tomar un

café.

• VB 2005, VB 2008 and VB 2010 IDE

• XML Literals

• VB 2010 Language features

… y si queda tiempo

• LINQ to ADO/SQL & Objects

• Interop Toolkit & PowerPacks

• Q & A

Estos son los emplazamientos:

Para los Grupos de Barcelona/Igualada/Vic:

Auditorio Ramon D'Abadal i Vinyals

C/ Historiador Ramon D'Abadal i Vinyals 5.

Edifici del Sucre

08500 – Vic

Barcelona

Para el Grupo de Tarragona:

Sala de actos de la Universidad Roviri i Virgili

Av. Països Catalans, 26

Campus Sescelades

43007 Tarragona

Para el Grupo de Valencia:

Universidad Politécnica de Valencia Edificio 1E

Salón de actos de la Facultad de Informática

Camino de Vera, s/n Valencia Valencia 46022

Para el Grupo de Alicante/Albacete/Murcia:

CLAVE INFORMÁTICA, S.L.

Galileo Galilei, 12 - Elche Parque Industrial

03203 TORRELLANO - ELCHE (Alicante) – ESPAÑA

Para el Grupo de Madrid:

http://madriddotnet.spaces.live.com/blog/cns!6453107D41F04C68!174.entry

Community Interview with Jonathan Aneja (Beth Massi)

VBTeam — Fri, 10 Oct 2008 19:00:41 GMT

Continuing the community interviews from our Italian Visual Basic MVP Alessandro Del Sole, this time we interview Jonathan Aneja, VB Compiler Program Manager.

Remember that you can take a look at the Visual Basic Team page for pictures and bios and visit the home page of the Visual Basic Developer Center for a link to all these interviews as well.

Here's the interview with Jonathan:

1. Nice to meet you Jonathan Aneja! Let’s begin by asking a simple question: where are you from?

Toronto, Ontario – one of the few places in Canada that’s actually *south* of Seattle :-)

2. We all know that you’re a Visual Basic Team member, but could we know something more about your role inside the Team?

I work on the compiler/runtime as a “Program Manager” (yeah, I don’t know what that means either :-)). Every week’s different, but typical stuff would include writing specs and taking notes in our language design meetings, dogfooding the product a lot to find bugs, prototyping features, and working with teams like ASP/MSBuild on how the compiler integrates with them. Even did some test automation back in Orcas!

I think the most important part of the PM role is understanding the customer and being able to “think like a VB developer”. Thankfully I’ve always been one – used every version of the product other than VB2 and VB5!

3. What’s your favorite Visual Basic feature regarding the language and/or the IDE?

Probably the background compiler. Case insensitivity too :-)

4. How long have you been working for Microsoft and what was your occupation before joining the VB Team?

Graduated in June 2005 and started as a contractor working in ISV Advisory Services. After about 9 months of that I moved out here to Redmond to join the VB team – 2.5 years and counting so far…

5. Why do you think VB is such a great language?
I think it’s really approachable and readable. It uses simple English terms like “Or” rather than requiring a beginner to learn a symbol like “|”. The IDE provides a ton of productivity features like Error Corrections and an amazing IntelliSense experience. The VB App Framework provides things like the My Namespace and application-level events automatically instead of making you wire all that up.

Features like “Handles” give you a powerful way to deal with events while abstracting away more advanced concepts like delegates. There’s still full support for delegates when you need to dive deeper, but for the simple case it reduces the concept count that the developer has to deal with. That’s a big part of the language’s philosophy: keep the number of concepts you have to remember low. This lets you focus on actually solving your business problem instead of learning every nuance of the compiler.

6. Have you ever been to Italy?

No but I’d love to visit someday :-)

7. Would you like to tell us something about your life outside the office (how do you like to spend your free time, what do you like to do when/if you go out in the evening or when you’re at home and so on)?

I really like Basketball, strategy board games (Settlers, Powergrid, Risk etc), and music. I’m also really interested in solutions to 3^rd world poverty and organizations likes Compassion International.

8. Who is your favorite musician?

Impossible to pick just one, but I’ll try to keep it to three: Chris Tomlin, Hillsong, and Casting Crowns

9. What’s your favorite food?

Chicken Tikka Masala

Thank you very much for taking time to answer these questions and letting us know something more about you!

Where is the VB Team going to be over the next few months? (Lisa Feigenbaum)

VBTeam — Mon, 29 Sep 2008 01:26:00 GMT

We have quite a few trips coming up over the next couple months, and we want to connect with you while we’re on the road. Here is our plan. Let us know where we can find you. ;-)

October 6-7, 2008

Software Development Conference 2008: http://www.sdc.nl/

Beth Massi

October 8-10, 2008

TechEd Hong Kong: http://www.microsoft.com/hk/technet/teched2008/

Karen Liu

October 21-23, 2008

OOPSLA: http://www.oopsla.org/oopsla2008/

Dustin Campbell

October 27-30, 2008

Professional Developers Conference: http://www.microsoftpdc.com/

Paul Vick

Dustin Campbell

Lisa Feigenbaum

Alex Turner

November 8-9, 2008

Silicon Valley Code Camp: http://www.siliconvalley-codecamp.com

Tim Ng

Beth Massi

November 10-13, 2008

DevConnections: http://www.devconnections.com/shows/FALL2008VS/default.asp?c=1&s=121

Lucian Wischik

Jay Schmelzer

Christin Boyd

John Stallo

November 10-14, 2008

TechEd EMEA: http://www.microsoft.com/emea/teched2008/

Jonathan Aneja

Lisa Feigenbaum

Karen Liu

Paul Yuknewicz

John Durant

November 17-20, 2008

Spain user group tour, Barcelona to Madrid

Jonathan Aneja

Lisa Feigenbaum

November 19-20, 2008

TechSummit Berlin: http://www.technical-summit.de

Paul Yuknewicz

John Durant

December 1-2, 2008

DevTeach Montreal: http://www.devteach.com/

Beth Massi

January 7-9, 2009

Code Mash: http://www.codemash.org/

Dustin Campbell

Finally, you can also find us at the .Net Developers Association meeting in Bellevue, Washington the fourth Monday night each month. http://netda.net

VB 2008 Language Deep Dive - Presentation Materials (Jonathan Aneja)

VBTeam — Thu, 21 Aug 2008 07:55:00 GMT

Last week I got the chance to visit the Toronto .NET User Group and give a talk on all the great new language features in VB2008. It was great to see so much excitement around LINQ and especially XML Literals!

The slides and demo code are posted at the link below; here’s the session abstract (with links inserted so you can find more info on each topic):

Language Integrated Query (LINQ) is a new platform feature in Visual Studio 2008 that allows you to access objects, databases, and XML through a common query syntax (in both VB and C#). In this talk, we’ll take a deep dive into the language features that LINQ uses internally to process your query, and see how they can be used in your own code. Topics we’ll cover include:

- Query expressions
- XML Literals
- Type Inference
- Anonymous Types
- Extension Methods
- Lambda expressions
- Closures
- Expression Trees
- Partial Methods
- Relaxed Delegates
- Performance/Deferred Execution
- LINQ to Dataset
- Dynamically constructing a LINQ query

We’ll also look at some of the cool new IDE features as well as free add-ons such as Refactor! which can greatly improve your day-to-day productivity. If you want to learn what makes VB the most powerful language for working with data then come on out!

Some of the resources mentioned on the last slide:

- VB Team blog (well, you’re already here J)

- Paul Vick’s blog (http://panopticoncentral.net)

- Beth Massi’s blog (http://blogs.msdn.com/bethmassi)

- MSDN VBasic site (http://msdn.com/vbasic)

For those of you who were asking about dynamically constructing LINQ queries at runtime, you can find more information on that here and here.

There were a ton of great questions from the audience so I’ll probably post an FAQ sometime next week. In the meantime don't forget to download VS2008 SP1, which allows you to use LINQ against SQL Server 2008.

How LINQ to Dataset works in VB (Jonathan Aneja)

VBTeam — Thu, 15 May 2008 02:52:00 GMT

LINQ at its core requires any data source to be queryable, which basically means it must implement IEnumerable. (It’s actually a bit more complicated than that, for a full explanation see section 11.21.2 of the Visual Basic 9.0 Language Specification). Now when working with LINQ to Dataset we have a problem: DataTable does not implement IEnumerable, so how can we query over it?

As we saw yesterday, Visual Studio 2008 includes an assembly called System.Data.DataSetExtensions.dll, which defines an extension method called AsEnumerable(). Here’s what this method looks like:

<Extension()> _

Public Function AsEnumerable(source As DataTable) As EnumerableRowCollection(Of DataRow)

Basically this takes in a DataTable and sends back something that implements IEnumerable(Of T), which LINQ can then consume using the standard query operators. So all you have to do is import System.Data (which is done by default in the project templates) and then you can use LINQ against a Dataset by calling AsEnumerable().

Dim customers = TestDS.Tables("Customers")

Dim franceCustomers = From cust In customers.AsEnumerable() _

Where cust!Country = "France" _

Select cust

Now one of the interesting things about the way LINQ works in VB is you don’t actually have to call AsEnumerable() explicitly for the code above to compile. Even though DataTable does not implement IEnumerable, the compiler helps out here by looking for methods that can turn it into something queryable. When the VB compiler encounters a LINQ query over a type that does not implement IEnumerable, IEnumerable(Of T), IQueryable, or IQueryable(Of T) it then does the following, in order:

1. See if there is a conforming Select method available on the type.

2. See if the type has an instance method named AsQueryable which returns a type that is queryable.

3. See if the type has an extension method in scope named AsQueryable which returns a type that is queryable.

4. See if the type has an instance method named AsEnumerable which returns a type that is queryable.

5. See if the type has an extension method in scope named AsEnumerable which returns a type that is queryable.

If at any point the compiler finds a method that matches, it inserts a call to it. When the System.Data namespace is imported, the compiler finds a match for DataTable on step 5, and inserts the call to AsEnumerable for you. As a result you can write LINQ to Dataset code like this example from the 101 LINQ Samples:

Dim customers = TestDS.Tables("Customers")

Dim franceCustomers = From cust In customers _

Where cust!Country = "France" _

Select cust

What this means is that you can LINQ-enable your types by providing an AsEnumerable extension method that returns something that is queryable.

Note that for strongly-typed Datasets you don’t need to call AsEnumerable, as they inherit from TypedTableBase(Of T) which implements IEnumerable. This is a new type in VS2008; in VS2005 the Dataset Designer would generate code that inherited from DataTable and then explicitly implemented IEnumerable itself.