The Visual Basic Team : Orcas

LINQ Cookbook, Recipe 3: Find all the prime numbers in a given range

VBTeam — Thu, 28 Jun 2007 20:21:00 GMT

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ-To-Objects

Instructions:

- Open Visual Studio 2008, and Click ‘File/New Project’. Find and double-click the ‘Console Application’ Icon

- Add the following code:

Module Module1

Sub Main()

Dim primes = GetPrimesInRange(1, 1000)

For Each n In primes

Console.WriteLine(n)

Console.ReadLine()

End Sub

Function GetPrimesInRange(ByVal low, ByVal high) As IEnumerable(Of Integer)

Dim range = Enumerable.Range(low, high)

Return From num In range _

From num2 In range _

Where num Mod num2 = 0 _

Group By num Into Count() _

Where Count = 2 _

Select num

End Function

End Module

- The grouping is used to select only those numbers that have exactly two factors (i.e. they're prime)

Closures in VB Part 4: Variable Lifetime

VBTeam — Fri, 15 Jun 2007 21:04:00 GMT

For previous articles in this series please see

Sorry for the long delay between posts here. We're getting Orcas out the door and getting this series completed takes a back seat to shipping.

Originally I wanted to talk about looping structures next. However when I started writing that post I realized that I had to talk about lifetime before the looping structures would make sense.

Prior to Orcas the lifetime of a variable in VB was the entire function. This presented several problems from a closures perspective. Imagine you had a looping structure and the value was used in a lambda expression.

    Sub LifetimeExample()
        Dim list As New List(Of Func(Of Integer))
        For i = 0 To 5

            Dim x = i * 2
            If True Then
                list.Add(Function() x)
            End If
        Next

        For Each f In list
            Console.Write(f() & " ")
        Next
    End Sub

In this example if we left the lifetime rules unchanged, there would be a single variable "x" for the entire function. That means that we would end up printing out

10 10 10 10 10

This is somewhat unexpected and essentially means that VB could not support complex Lambda scenarios. To fix this we altered the lifetime of variables to be tied to the scope they were contained in. The end effect is that each iteration of the loop has a separate "x" since each iteration enters and leaves the scope of the "if" statement. As a result it will print out

0 2 4 6 8 10

We did make one backcompat adjustment for this change. The lifetime of variables in VB was visible if you tried to use an uninitialized variable in a loop/goto. For instance the following code will also print out 0 2 4 6 8 10 because it takes advantage of the fact that the variable "x" has a lifetime longer than the loop.

    Sub VisibleLifetime()
        For i = 0 To 5
            Dim x As Integer
            Console.WriteLine(x)
            x += 2
        Next
    End Sub

To make sure that we didn't break any existing code we had one little errata for the change. When a variable's scope is re-entered, and hence recreated, and it is not initialized to a value it will get the last value of the variable.

Jared Parsons (http://blogs.msdn.com/jaredpar )

What is the difference between VB 9, VBx and Silverlight? (Scott Wisniewski)

VBTeam — Fri, 08 Jun 2007 01:58:00 GMT

I recently received an email from a customer asking for clarification as to what the difference was between VB 9, VBx and Sliverlight. In particular, it seems as if we have been releasing so much information about cool new stuff that at least a few people have become confused, making them a bit nervous about the future of VB.

The customer had also expressed some concerns about upgrading from VS 2005 to Orcas (VS 2008), particularly because he was considering making an upgrade from VB 6 to VS 2005 and wanted to make sure he would be able to take advantage of Orcas when it was released.

I figured there may be other customers that have similar concerns, and so thought this would make a good blog post, particularly because it's been a while since I've posted anything (J).

As a result I've included a few of the questions he asked (paraphrased) below, along with my answers.

I hope this helps.

What is the difference between VB 9 and VBx? Which one is the next version of Visual Studio?

Visual Basic 9 is the next version of Visual Basic. Visual Basic 10, or VBx as it's sometimes called, is the version of Visual Basic that will follow VB 9. Currently VBx is in very early stages, and is a long way off from production. In fact, most of our development team is actively working on VB 9.

Why on earth would you start talking about VB 10 before you've even released VB 9? This is confusing.

The product cycle for VB 9 is starting to wind down. We recently released Beta 1 of Visual Studio Code Name "Orcas", and are currently working on releasing Beta 2. As the product cycle starts to wind down, our language design team is starting to think about what the "next next" version of the product will look like. They do this mainly as a way to "keep the pipeline moving". If they had to wait until VB 9 was 100% complete before they started thinking about VB 10, then there would end up being a significant delay from when we finished VB 9 until we could start working on VB 10. This is because designing a product, and coming up with a plan to develop it can be extremely time consuming. It requires us to come up with a design, create a schedule, make any necessary organizational changes, and ensure we have the right staffing levels, all before we start coding. By "overlapping" the early design work for VB 10 with the "end game" work for VB 9 we are able to better "bootstrap" the whole process, thus making the transition from one project to the next as smooth as possible.

As our design team comes up with designs they like to release information about them as early as possible. The earlier we can get information out to our customers, the earlier we can get feedback about the things we are doing. This helps us to build the products that actually meet our customers' needs. One thing we've managed to learn over the years is that the best possible way we can learn what it is that our customers want is to engage with them early and often.

As a result, near the end of a product cycle we will release information about our plans for the version of the product to follow the one we are currently working on. This gives our customers the chance to comment on it and let us know what they think. We then take that feedback and use it to develop a more complete plan for what we want to do.

What is VB 10 going to be like? What is this Silverlight Thing I keep hearing about? Is Silverlight a replacement for Visual Studio?

Our plans for VBx and Silverlight are still very rough and are nowhere near complete. As our customers start to use VB 9 and provide us with feedback that data will drive exactly what we end up doing in VB 10. That being said, however, we do have some rough ideas of the things we would like to do.

Silverlight 1.1 is a new light weight version of the .NET Framework that will allow you to develop rich applications that run in a web browser using .NET languages. The basic idea is to allow you to replace client side java script with .NET enabled languages, allowing you to write both the client side and sever side portions of your web applications in the same language. It also allows you to use WPF (windows presentation foundation) and WCF (windows communication foundation) to create extremely rich and interactive web applications in a way that is much easier than what is possible using HTML, Ajax, Java Script, or Flash.

VB 10 is going to be the version of Visual Basic that will follow VB 9 (the "next next version"). It will include new features designed to make VB a really great language for developing SilverLight apps, as well as enhancements to many of the new feature we are delivering in VB 9, such as Linq. You should still be able to do all the things with VB 10 that you could do with both VB 9 and VB 8.

The migration from VB 6 to VS 2005 is non-trivial. If I upgrade to VS 2005 will I able to use VB 9 when it comes out, or will I have to scrap all my work? What about VB 10? Should I be worried about the future of VB?

The transition from VB 8.0 to VB 9.0 should be smooth and relatively painless. We have gone to great lengths to ensure this.

Our plan is to also make the migration from VB 9 to VB 10 equally painless.

Although the migration from VB 6 to VB.NET is a bit tough, we are actively working on making that easier as well. We have been releasing a "VB Interoperability Toolkit" that allows an application to be gradually migrated from VB 6 to VS 2005, rather than requiring the whole thing to be migrated at once.

You can get more information about it here:

http://msdn2.microsoft.com/en-us/vbasic/aa701257.aspx

As far as the future of VB, you should definitely not be worried.

Microsoft is committed to VB, and making it a great language for developing applications for our various platforms. The future of VB should be a bright one!

Visual Basic LINQ Hands On Labs for Orcas Beta 1 (Beth Massi)

VBTeam — Mon, 04 Jun 2007 18:23:00 GMT

The VB team just posted some Hands On Labs on LINQ and LINQ to SQL for Orcas Beta 1. The first lab provides an introduction to The LINQ Project. You'll look at basic LINQ features including the Standard Query Operators, and you'll see how these features can be used against in-memory collections, connected databases, and XML documents. The second lab aims to provide a clear picture of the relational data access support provided by the LINQ Project, referred to as LINQ to SQL.

Enjoy!

- Beth Massi, VS Community

Closures in VB Part 3: Scope

VBTeam — Fri, 25 May 2007 21:03:00 GMT

Jared here again. For previous articles in this series please see

Thus far in the series we've only lifted variables that are declared in the same block/scope. What happens if we lift variables in different scope? The answer is that one closure class will be created for every unique scope where a lifted variable is declared and all of the variables in that scope that are lifted will be placed in that closure. Once again, examples speak best

    Sub Scope1()
        Dim x = 5
        Dim f1 = Function(ByVal z As Integer) x + z
        Console.WriteLine(f1(5))
        If x > 2 Then
            Dim y = 6
            Dim g = 7
            Dim f2 = Function(ByVal z As Integer) z + y + g
            Console.WriteLine(f2(4))
        End If
    End Sub

The code will end up looking like so ...

    Class Closure1
        Public x As Integer

        Function Lambda_f1(ByVal z As Integer)
            Return x + z
        End Function

    End Class

    Class Closure2
        Public y As Integer
        Public g As Integer

        Function Lambda_f2(ByVal z As Integer)
            Return y + z + g
        End Function
    End Class

    Sub Scope1()
        Dim c1 As New Closure1()
        c1.x = 5
        Console.WriteLine(c1.Lambda_f1(5))
        If c1.x > 2 Then
            Dim c2 As New Closure2()
            c2.y = 6
            c2.g = 7
            Console.WriteLine(c2.Lambda_f2(4))
        End If
    End Sub

There are a couple of items to take away from this example.

Only two closure classes were created even though three variables were lifted. The number of closures only depends on the number of scopes of all of the lifted declared variables.
The closures are created at the begining of the scope they are associated and not at the begining of the method. This will be more important in the next part of the series.
Each lambda instance is attached to the closure associated with the scope the lambda is declared in.

The next twist is what were to happen if the lambda "f2" were to also use the variable "x". As it's currently written there is no association between Closure1 and Closure2 therefore there is no way for it to access the lifted variable. The answer is two fold. Firstly to reduce clutter I pasted the closure classes as if they were separate entries. In fact Closure2 would appear as a nested class of Closure1 in the real generated code.

Secondly if x were used inside of "f2", the real use would be "c1.x". That's (almost) no different than "someOtherVar.x". Therefore the instance of c1 will be lifted into Closure2.

Dim f2 = Function(ByVal z As Integer) z + y + g + x

Woud result in the following definition of Closure2 ...

    Class Closure2
        Public y As Integer
        Public g As Integer
        Public c1 As Closure1

        Function Lambda_f2(ByVal z As Integer)
            Return y + z + g + c1.x
        End Function
    End Class

In deeply nested lambdas and scopes this type of lifting will continue recursively.

That's it for this entry, the next article will talk about looping structures and possibly variable lifetime.

Closures in VB Part 2: Method Calls

VBTeam — Thu, 03 May 2007 23:22:00 GMT

For previous articles in this series, please see

Part 1 - The basics

Jared here again. This part of the series will focus on how method calls are handled in closures. As stated in the previous article, the purpose of closures is to allow all operations inside a lambda or query expression that would normally be available inside the function or sub. To do this closures often need to capture (or lift) relevant variables from the function into the generated class.

There are 2 types of methods and method calls that closures have to handle.

Method calls to a shared method or methods on modules.
Method calls to instance members of a class

Scenario #1

Below is an example of a method call inside a lambda expression for scenario #1.

Module M1

    Function MyValue() As Integer
        Return 42
    End Function

    Sub Example1()
        Dim x = 5
        Dim f = Function() x + MyValue()
    End Sub

End Module

Here we are calling a module method inside a lambda. Module Methods or Shared methods can be called from anywhere because they require no specific variable for the call. This requires no special work from closures as the call can just be made naturally.

    Class Closure
        Private x As Integer

        Function Lambda_f() As Integer
            Return x + M1.MyValue
        End Function
    End Class

Scenario #2

Calling an instance method is more difficult than a shared method because it requires the referenc "Me". If you don't type this specifically in code the VB Compiler will add it for you under the hood. To make this work the closures code will also "lift" the variable "Me" in the same way that it lifts normal variables in a function.

Calling a instance method inside a lambda expression is little difference than calling a member method on a variable used in a lambda. The only difference is the variable is "Me". For example

Class C1
    Private m_myValue As Integer

    Function MyValue() As Integer
        Return m_myValue
    End Function

    Sub Example2()
        Dim x = 5
        Dim f = Function() x + MyValue()
    End Sub
End Class

In this case we need to access both "x" and "Me.MyValue()" from the closure. The generated code will create space for both of these variables and the transformed code in Example2 will store both of the values.

Class Closure
    Private x As Integer
    Private OriginalMe As C1

    Function Lambda_f()
        Return x + OriginalMe.MyValue()
    End Function
End Class

    Sub Example2()
        Dim c As New Closure
        c.x = 5
        c.OriginalMe = Me
        Dim f = New Func(Of Integer)(AddressOf c.Lambda_f)
    End Sub

As usual, the generated code is much uglier but this essentially what will be generated. That wraps it up for method calls. In the next part, I will discuss the variable liftetime and scoping issues that come into play with closures.

Jared Parsons

http://blogs.msdn.com/jaredpar

Closures in VB: Part 1

VBTeam — Thu, 03 May 2007 03:53:00 GMT

My name is Jared Parsons and I am a developer on the VB Compiler and Debugger. One of the features I implemented for VB 9.0 is lexical closure support. This a great addition to the VB language and I wanted to do a series of blog posts to describe this feature and how it will impact your code.

Lexical Closures (more often referred to as simply Closures) are the underpinnings for several new features in Visual Basic 9.0. The are part of the guts of Lambda and Query expressions. This will be a several part series on Closures in VB 9.0; how they work, their limitations, pitfalls surrounding their use.

To start off, let's get a basic summary of what a Closure is. Wikipedia defines it as "... a is a semantic concept referring to a function paired with an environment ...". I prefer to describe it as follows. A closure is a feature which allows users to seemlessly access an environment (locals, parameters and methods) from more than one function. Even better are samples :)

    Class C1
        Sub Test()
            Dim x = 5
            Dim f = Function(ByVal y As Integer) x + y
            Dim result = f(42)
        End Sub

    End Class

In this code we have a lambda expression which takes in a single parameter and adds it with a local variable. Lambda expressions are implemented as functions in VB (and C#). So now we have two functions, "Test" and "f", which are accessing a single local variable. This is where closures come into play. Closures are responsible for making the single variable "x" available to both functions in a process that is referred to as "lifting the variable".

To do this the compiler will take essentially 4 actions.

Create a class which will contain "x" in order to share it among both functions. Call it "Closure" for now
It will create a new function for the lambda expression in the class "Closure". Call it "f" for now
Create a new instance of the class "Closure" inside the sub "Test"
Rewrite all access of "x" into the member "x" of "Closure".

    Class Closure
        Public x As Integer

        Function f(ByVal y As Integer) As Integer
            Return x + y
        End Function
    End Class

    Class C1
        Sub Test()
            Dim c As New Closure()
            c.x = 5
            Dim f As Func(Of Integer, Integer) = AddressOf c.f
            Dim result = f(42)
        End Sub

    End Class

Now "x" is shared amongst both functions and the user didn't have to know anything about the code we generated. You can see from this simplified example just how much code Closures and all of the other new VB 9.0 features are saving you here (Type Inference, Lambda Expressions).

Note this is only a simulation of what is generated when you use a closure, the actual generated code is much uglier and involves lots of unbindable names "$Lambda_1", etc ...

In the next part of this article I'll dive into some more uses of closures (multiple variables, method access, terminology, etc...).

Jared Parsons

https://blogs.msdn.com/jaredpar

VB On Silverlight

VBTeam — Tue, 01 May 2007 20:32:00 GMT

One of the great things about being on the VB team is that we’re generally in the loop early and often with teams developing new technologies and products. It’s always exciting to see ideas take shape, evolve into a product, and eventually hit the market—often after four or five code names, a couple of tech previews, and a few release date/year extensions. Despite my best efforts, the sheer volume of new stuff coming out is a bit overwhelming; and maintaining more than a cursory understanding of the products that are incubating at Microsoft is pretty challenging. But when some partner teams started asking what it would take to write VB.NET code-behind for a browser plug-in that could run cross-browse and cross-platform, my interest was definitely peaked. “Let me get this straight… You want to write a web plug-in VB.NET… that doesn’t require the full .NET framework to be installed… and runs on the Mac… and Firefox … but supports the full VB.NET language? Uh… Okay, let’s chat.”

It has only been a few months and a handful codename changes since we had that discussion (For a humorous history of Silverlight’s codenames, check out Tim Sneath’s blog.) , and despite a number of obstacles, we’re getting there with the Alpha release of Silverlight v 1.1. And while I’m by no means a Silverlight guru, I have been using it for a little while now and I thought I’d shed some light on what’s out there for VB developers who are interested in trying out Silverlight v1.1.

The Visual Basic Language on Silverlight

Prior to the announcement of Silverlight 1.1, Silverlight plug-ins were written in XAML and Javascript. While the Javascript model is certainly powerful, using VB is always my preference—it’s a language I know well, and its flexibility suits my programming style. Not to mention that the introduction of VB.NET into the Silverlight world brings with it many of the .NET Framework’s types and APIs I’ve come to rely on.

If you’ve had a chance to download the Silverlight 1.1 runtime, you may have noticed that it’s MUCH smaller than the full .NET Framework at 4.2 MB (and hopefully shrinking!). Clearly, some things have been factored out of the .NET Framework to keep the download size down and installation time short. And although a lot has been removed, the core set of types is included along with some APIs that are particularly useful for writing plug-ins—things like a “lite” version of System.Xml.dll, support for making web service calls, and so on. When deciding what aspects of the Visual Basic language and runtime should be included with Silverlight v1.1, we tried to follow a similar pattern: we wanted to preserve the core VB programming experience—late binding, conversions, Linq, and so on; and we didn’t want to bloat the download size with anything that wasn’t absolutely necessary or didn’t make sense in Silverlight—things like some of the COM helpers (COM is not supported in Silverlight), financial functions, etc. It was a delicate balance to strike between functionality and overall size. The Silverlight 1.1 Alpha is our first crack at it… and it may be refined over the coming months with feedback. Here’s a laundry list of what’s supported/not supported currently. (If you’re interested in digging into the details, you can also view the types in the Object Browser using the tools described below.)

Supported…

Late Binding: One of the most definitive features of the VB language, I find late binding to be especially useful in writing Silverlight code-behind.
Conversions: Implicit and explicit conversion operators are available—Ctype, CStr, etc.
Linq: Currently, Linq over objects is supported
String utilities: Len(), InStr(), Mid(), UCase(), etc
VB Collection: Most folks either love it or hate it. A subset of generic collections is also supported. (Non-generic collections are considered obsolete for Silverlight.)
- Dictionary(Of Key, Value)
- List(Of T)
- ArrayList (Obsolete)
- BitArray (Obsolete)
- Hashtable (Obsolete)
- Queue (Obsolete)
- SortedList (Obsolete)
- Stack (Obsolete)
Math utilities: Rnd(), Random()
IIF()
Information utilities: Things like IsNumeric(), IsDate(), UBound(), LBound(), and so on
Date utilities: Now(), TimeOfDay(), Year(), etc
Constants: vbCrLf, vbTab, etc. Some of the more obscure constants have been removed, but the core set is included.
All core VB Language Constructs: Type Inference, anonymous delegates, Handles, etc

Not Currently Supported…

The My Namespace: We removed this for Alpha release because much of the existing My Namespace doesn’t make a ton of sense in Silverlight.
XML Literals: The compiler support for XML literals is present, but System.Xml.Linq (which the feature depends on) is not available in Silverlight 1.1.
COM Support: Silverlight plug-ins are not allowed to call COM components, so we removed the VB utilities related to COM (e.g., the COM Class attribute)
FileSystem Object (VB6 Compatibility): Direct access to the file system is not permitted, so these APIs were removed. Alternatively, you might check out System.IO.IsolatedStorage if you need to persist data locally

As a sort of test piece, I recently took a look at the Clock Sample and wanted to see if the feature set we settled on enabled me to write VB code as I normally would for a Windows Forms or WPF application. The code basically just sets the minute, second, and hour hands on the clock to the current time (approximately). Here’s what it looks like…

' Anonymous delegates, Handles--isn't it pretty?

Public Sub Canvas_Loaded() Handles Me.Loaded

    InitializeComponent()

    ' Type inference; DateTime functions

    Dim currentTime = Now

    ' Conversions, type inference

    Dim hourAngle = ((currentTime.Hour / 12) * 360 + currentTime.Minute / 2) + 180

    Dim minAngle = ((currentTime.Minute / 60) * 360) + 180

    Dim secAngle = ((currentTime.Second / 60) * 360) + 180

    ' hourAnimation is a generated variable that makes use of WithEvents and Conversions

    '     Protected WithEvents hourAnimation As DoubleAnimation

    '     Me.hourAnimation = CType(Me.FindName("hourAnimation"),DoubleAnimation)

    hourAnimation.From = hourAngle

    hourAnimation.To = hourAngle + 360

    minuteAnimation.From = minAngle

    minuteAnimation.To = minAngle + 360

    secondAnimation.From = secAngle

    secondAnimation.To = secAngle + 360

End Sub

All in all, this particular example looks and feels pretty VB to me—which isn’t to say we’ve nailed it by any means… but the example does give some indication as to the type of VB experience we’re striving for with Silverlight. Let us know what you think.

Tools for building Silverlight Plug-ins with VB

Unless you’re really into notepad , download the tools for Silverlight. The VS project templates alone are worth the bandwidth required, as they’ll get you started in the right direction. In addition, many of the more interesting things you can do with Silverlight (e.g., animations, embedding videos, etc) are pretty tedious to wire-up by hand in XAML; using Expression Blend makes the process *much* easier. All of the components mentioned below are available at: http://silverlight.net/GetStarted/. I’ve just included them here for convenience.

What to download

Silverlight 1.1 Runtime: This is the version of Silverlight that enables you to write VB code-behind. It includes a version of the factored .NET Framework, including the VB runtime (Microsoft.VisualBasic.dll).
ASP.NET Futures Runtime: Among other features, the controls included in this download make it much easier to embed Silverlight controls and rich media in existing ASP.NET web applications
VS Orcas Beta 1: Note: You need to have the official Orcas Beta 1! Earlier CTPs won’t cut it. Even if you choose not to use Visual Studio to do your development, you’ll need the Beta 1 VB 9.0 compiler, as it includes some changes required to target the slimmed-down .NET Framework.
VS Add-On for Silverlight: This component provides some project templates and IDE changes for building Silverlight applications in VB (and C#).
Expression Blend 1.1 CTP: The VS Add-On mentioned above does not include a designer for Silverlight; editing XAML is done in the XML editor. While the XML editor does support IntelliSense, I find it much easier to perform the visual and story board layouts in Expression Blend. (See the note below for the workaround required to use VB & Blend.)
Silverlight SDK: The most interesting content in the SDK is the reference documentation for the VB runtime. It basically details what functions and types in Microsoft.VisualBasic.dll. The download also includes samples, although I generally prefer to see them online here: http://silverlight.net/quickstarts/managed.aspx.

If you run into any problems getting this stuff installed, please post the problem at the forums, http://silverlight.net/forums/.

Workarounds

Okay, almost there… we just need to work around one somewhat confusing bug in Blend you’ll run into when you try to create a VB project:

The problem here is that Expression Blend is configured to build VS 2005/VB 8.0 projects, but only VB 9.0 supports building Silverlight 1.1 applications. To work around the issue, you’ll have to re-configure Blend to use VS Orcas & VB 9.0 (Sigh!). Here’s how…

Close Microsoft Expression Blend.
Navigate to \Program Files\Microsoft Expression\Blend 1.1\.
Create a new XML file in that folder and then rename the file to Blend.exe.config.
Paste the following XML snippet into Blend.exe.config.
Save Blend.exe.config and close it.
Open Microsoft Expression Blend. Select “Visual Basic” as the language and you can create “Silverlight Application” projects.

Blend.exe.config

<?xml version ="1.0"?>

<configuration>

    <startup>

        <supportedRuntime version="v2.0.50727" safemode="true"/>

        <requiredRuntime version="v2.0.50727" safemode="true"/>

    </startup>

    <runtime>

        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

            <dependentAssembly>

                 <assemblyIdentity name="Microsoft.Build.Framework" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>

                <bindingRedirect oldVersion="0.0.0.0-99.9.9.9" newVersion="3.5.0.0"/>

            </dependentAssembly>

            <dependentAssembly>

                <assemblyIdentity name="Microsoft.Build.Engine" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>

                    <bindingRedirect oldVersion="0.0.0.0-99.9.9.9" newVersion="3.5.0.0"/>

            </dependentAssembly>

        </assemblyBinding>

    </runtime>

</configuration>

Just keep in mind that if you uninstall Orcas and you want to continue using Blend, you’ll need to delete Blend.exe.config.

A lap around the tools

You’re pretty much good to go at this point. With the installation of the Visual Studio Add-On, two new project types are available: a standalone Silverlight Web Application and Silverlight Class Library.

I generally find the “Silverlight Project” the most useful template to work with. It includes basic XAML and VB code-behind files, Javascript goo required to instantiate the control, and a boilerplate HTML page that hosts the control. The project can be debugged by F5’ing TestPage.html, although Edit-and-Continue is not supported for Silverlight projects.

The programming model for Silverlight 1.1 is very similar to that of ASP.NET and WPF: the UI aspects of the control are declared in the .xaml file, and events are handled in the code-behind (.xaml.vb) file. Similar to desktop WPF, each named UI element declared in XAML has a corresponding variable that can be referenced in code-behind.

For example, the following TextBlock declared in Page.xaml…

<TextBlock x:Name="TextBlock1" Text="1234" />

Can be referenced in Page.xaml.vb as follows…

Private Sub TextBlock1_MouseEnter() Handles TextBlock1.MouseEnter

Me.TextBlock1.Opacity = 1

End Sub

If you’re interested in checking out what’s available in the .NET Framework for Silverlight, you can poke around in the Add Reference dialog and/or Object Browser. The former is filtered to only show what you can use in Silvelight 1.1.

The Silverlight tools are very much in an Alpha state, so your mileage may vary a bit. In particular, debugging VB applications can be a somewhat bumpy ride… so please let us know on the forums if you run into any issues.

Additional resources to check out

There are already some pretty vibrant community resources on Silverlight popping up. Many of these include sweet looking samples, and the amount of content should continue to grow in the coming months. The main place to keep an eye on is the main Silverlight site and the Silverlight forums.

By all means, feel free to share your impressions of VB on Silverlight. It’s early and we could really use the feedback. Thanks!

Joe & The VB Team

The Best of Intentions (Matt Gertz)

VBTeam — Mon, 30 Apr 2007 19:39:00 GMT

The title pretty much describes this post. I had fully intended to work on a Smart Device application for VB last week, and post the walkthrough here. VB is a great language for coding against devices, and there are a lot of cool things you can use a device for, so I was looking forward to a fun post on that this morning. However, I ended up needing to dig into some administrative work last week, and so I must apologize for not getting to the coding. I’m hoping that this current rush will wind down later this week, and I can refocus on a little app building.

The root cause of my personal administrative churn last week is simply that we’ve got a lot of exciting things going on right now! We are now into the phase of the product that I like best; the phase that’s the most fun for me. Some people like the design phase, others like the coding phase, but I personally dig the part where the features come together and we can see the scenarios start to work end-to-end. I’m always amazed at how a bunch of separate features planned by different teams can play so well together by the first beta, but this particular beta has been specifically pleasing in that regard.

Take a feature like Linq, for example. The Linq features involve the C# team (both on the underlying DLinq DLLs and the C#-specific compiler & IDE Linq work), the VB team (both on the Compiler & IDE work as well as the designer work), and the XML team; the debugger teams are clearly impacted as well, as are any teams which produce products that support our languages such as the VS Tools for Office team and the Visual Web Designer team (among others). The features have to install correctly, which involves the our setup team, and of course everything needs to work within the constraints of the .NET framework, the Core IDE, and SQL. I’ve joked with some of our customers that Linq is “the feature that ate our lives,” and in a sense, it’s true: it’s a lot of teams that have to keep their eyes on the prize for so many months to one degree or the other. Despite this, the feature set feels very solid to me these days; a lot of great work has gone into the codebase, and the new engineering techniques & processes we’ve been using have been making a huge, positive, and noticeable impact . Getting all of the bits and pieces together for Beta 1 went so smoothly that it was almost eerie, thanks to the diligence of the teams involved.

The features themselves are of course fun to play with. VB is one of the larger teams in the division and thus my job of development manager is more “manager” than “development”-- I rarely get my hands into the actual coding these days, beyond architectural discussions and the odd bug fix or two. I compensate by filling in the gaps in my schedule with trying out all of the new features. Having gotten used to the stability and usefulness of those new features in my office, I find myself automatically searching for these features when programming for fun at home, thus experiencing that momentary let-down when I realize I don’t have them available to me at home yet! Ah, it’s hard to be patient…

So, no fun tricks with VB2005 from me this week – I’ll try again next week. But, in the interim, you should know that things are looking *really* good here for Orcas! I hope you enjoy trying out Beta1...

--Matt--*

Visual Basic LINQ Samples Updated for Orcas Beta 1! (Beth Massi)

VBTeam — Fri, 20 Apr 2007 18:04:00 GMT

The Visual Basic LINQ Samples have been updated for Visual Studio Orcas Beta 1! This is a set of 101 samples that demonstrate all the features of Visual Basic's Language Integrated Query in Orcas Beta 1.

Also check out the The LINQ Project page. This has been updated with links to some news articles and quote highlights that give an overview of the history of Microsoft's Language Integrated Query (LINQ) project, the reasons behind its development, and the benefits and features LINQ offers to developers.

We’re also continuing to update the main Visual Basic Developer Center with more content so check there often!

-Beth Massi, Program Manager VS Core Community

Visual Basic "Orcas" Beta1 is in the wild! (Amanda Silver)

VBTeam — Thu, 19 Apr 2007 23:20:00 GMT

Woohoo! Its official, we finally got Orcas Beta1 out the door! We’re very excited to get this release out to you so we can finally talk about some of the stuff we’ve been working on in addition to the LINQ and XML feature-set. We believe that Orcas Beta1 displays all of the essential value in the Orcas product but it’s important to keep in mind that it’s not feature-complete. There are many features (for example: lambda expressions, support for nullable types, etc.) that will be coming online in a later milestone.

That said, back to Beta1! Recently, there’s been a lot of discussion on this blog about the LINQ features, but I’d like to take the time to discuss some of the language and compiler related features in Orcas Beta1 that will radically improve your productivity even if you don’t give a hoot or holler about the revolution in programming that we fondly call LINQ.

The first thing that’s going to jazz you is Intellisense Everywhere. In short, this feature is about providing statement completion suggestions at new points in your editing experience. Some examples are best shown as screen shots:

Expressions:

Keywords:

Variable names:

I’ll save the rest so as not to steal the thunder from another blogger on our team….

Another great feature that you’ll notice in Beta1 is Relaxed Delegates. In short, relaxed delegates are a way to extend VB’s implicit conversions to delegate types. With relaxed delegates, you can write the following code:

Private Sub Button1_Click(ByVal sender As Object, ByVal e As EventArgs) _

Handles Button1.Click, Button1.MouseClick

MsgBox("Do Something")

End Sub

You can even omit *all* of the event arguments if your method body doesn’t need them. This improves readability without compromising type safety:

Option Strict On

Public Class Form1

Private Sub Button1_Click() Handles Button1.Click, Button1.MouseClick

MsgBox("Do Something")

End Sub

End Class

Lastly, Multi-Targeting enables you to use Orcas Beta1 to write applications that target .NET 2.0, 3.0, or 3.5. This has been a long requested feature that is now in your hands. The idea is that by supporting multi-targeting, it’s a no-brainer to go out and pick up Orcas because it doesn’t necessarily require that you deploy a new runtime if you don’t use the features of .NET 3.5 – just your app. You can see this by going to FileàNew Project and changing the option in the dialog:

Hope these features find you well! Download the Beta and tell us what you think!

"Live From Redmond: Orcas Overview" Webcast Rescheduled (Beth Massi)

VBTeam — Thu, 19 Apr 2007 00:10:00 GMT

Live Meeting had some technical issues for this morning's webcast with John Stallo. Sincerest apologies from the Visual Basic team. We’ve rescheduled the webcast for this Tuesday, April 24th. Please register here. Also don't forget to register for the other incredible webcasts from other members of the team. You can always find the latest information on all the webcasts on the Visual Basic Developer Center.

-Beth Massi, Program Manager VS Core Community

Live From Redmond Webcast Series (Beth Massi)

VBTeam — Mon, 09 Apr 2007 19:00:00 GMT

The Visual Basic team has put together a "Live from Redmond" webcast series aimed at the next version of Visual Basic and Visual Studio code named "Orcas". The live series starts April 18th and will continue to the end of May. Come join us for this exciting series direct from the Visual Basic team!!

Here's the schedule (check the VB Developer Center for updates):

Live From Redmond: VB9 - Orcas Overview RESCHEDULED April 24th, Presented by John Stallo
Live From Redmond: VB9 - LINQ Overview April 25th, Presented by Kit George
Live From Redmond: VB9 - LINQ to SQL & O/R Designer Deep Dive May 2nd, Presented by Young Joo
Live From Redmond: VB9 - Building N-Tier Applications May 9th, Presented by Young Joo
Live From Redmond: VB9 - Offline Data Caching May 16th, Presented by Milind Lele
Live From Redmond: VB9 - Deep Dive into LINQ May 23rd, Presented by Amanda Silver
Live From Redmond: VB9 - Building Service-Oriented Applications May 30th, Presented by John Stallo

UPDATE: The VB Team has added more webcasts for June!

Live From Redmond: Using the Interop Toolkit to Migrate your VB6 Applications to .NET June 6th, Presented by Jonathan Aneja
Live From Redmond: VB9 – LINQ Best Practices June 13th, Presented by Lisa Feigenbaum

Hope to see you at the webcasts! For more webcasts past, present and future, please visit the VB Webcasts page.

-Beth Massi, Program Manager VS Core Community

Partial Methods

VBTeam — Wed, 28 Mar 2007 04:03:00 GMT

About two weeks ago I had the opportunity to attend the product group dinner associated with the Global MVP Summit that was behind held here at Microsoft. Besides a free meal, this also gave me the excellent opportunity to meet with some of our MVPs and discuss their impressions with Visual Studio and all the cool new features we are introducing for Orcas. At the dinner, I had an opportunity to talk with a group of VB MVPS from Japan, who met with me and about 5 or 6 other members of the VB team. While we were talking, a couple of them asked me a few questions about partial methods. Unfortunately, I do not speak Japanese, and so had some trouble answering them. Figuring that written English may be easier to understand than my idiomatic spoken English, I decided to make Partial Methods the topic of my next blog post.

As a result, I've included their questions below along with my answers.

What are Partial Methods?

In a nut-shell, partial methods are a light-weight replacement for events designed primarily for use by automatic code generators. They are declared by creating a private method with an empty body and decorating it with the Partial keyword. The method may then be "re-implemented" elsewhere within its containing class. If the method is implemented, then the compiler will redirect all calls to the partial method to the implementing method. If the method is not implemented in its containing class, then the compiler silently removes any calls to it from the program. They differ from events in several ways, mainly:

A partial method can only have 1 "implementing method", where events may have any number of handlers
The implementing method for a partial method must be in the same class as the partial method its self, where as event handlers can pretty much be defined in any type that has access to the event instance
An event will throw if it has no handlers and is invoked. Usually this requires comparing the event against Nothing to safe guard against an exception. On the other hand, if a partial method does not have an implementing method then the compiler will simply optimize away any calls to it.
The wiring of events is dynamic, which means that handlers can be added and removed from an event at runtime. This can either be done implicitly, using WithEvents variables and Handles clauses or explicitly using AddHandler and RemoveHandler statements. The wiring of partial methods, however, is always done at compile time, and an implementing method is associated with its declaring method by simply writing a method with the same name and signature as the partial method. Once this is done, all references to the partial method are rewritten by the compiler to refer to its implementing method.
Events may be declared with any accessibility (public, private, or friend). Partial Methods, on the other hand must be private. The method that implements it, however, may have any accessibility.

An example use of partial methods is shown below:

'Designer File
Partial Class DesignerGeneratedClass
    Partial Private Sub OnFoo()
    End Sub

    Partial Private Sub OnBar()
    End Sub

    Sub DoSomething()
        OnFoo()
        OnBar()
    End Sub
End Class

'Code Behind File
Class DesignerGeneratedClass
    Public Overridable Sub OnFoo()
        Console.WriteLine("Foo Occured")
    End Sub
End Class

Here we define a class named DesignerGeneratedClass split into two partial classes. It is designed to mimic typical code generation scenarios where one partial class contains designer generated code and another contains user generated code. For example, Windows Forms classes and pages in ASP.NET Web Application Projects utilize this approach. In the designer generated file we define a utility method, DoSomething, that calls two partial method declarations OnFoo and OnBar. The user file implements OnFoo, but not OnBar. When the VB compiler processes this class, it notices this and emits a body for DoSomething() that only calls OnFoo().

What are Partial Methods useful for?

For most applications, events are almost always a better choice than partial methods due to their increased flexibility. However, there are some scenarios where they come in handy. A couple of them are listed below:

In automatic code generators

Partial methods enable code generators to write extremely flexible code by creating a lot of "hooks", where developers can provide their own custom functionality that integrates into the "boiler plate" code created by the generator. Because the hooks are optimized away if they aren't used, no performance penalty is introduced by defining them. This is really useful if generated code needs to be used in high performance scenarios. For example, partial methods are used by the DLINQ designer for exactly this purpose. Developers wishing to invoke custom code on their data objects when properties are set can do so without requiring all users of DLINQ to suffer performance problems.
To increase the readability of code that uses conditional compilation constants.

Consider the following code that uses conditional compilation constants in VB.

Class UglyConditonalCompilationCode

#If DEBUG Then
    Private Sub LogMessage(ByVal s As String)
        Console.WriteLine(s)
    End Sub
#End If

    Sub DoStuff()
        DoFirstThing()
#If DEBUG Then
        LogMessage("Did first thing")
#End If
        DoSecondThing()
#If DEBUG Then
        LogMessage("Did second thing")
#End If
        DoThirdThing()
#If DEBUG Then
        LogMessage("Did third thing")
#End If
    End Sub
End Class

This code is obviously difficult to read. However, using partial methods it is possible to make the code much more readable:

Class PrettyConditonalCompilationCode
    Partial Private Sub LogMessage(ByVal s As String)
    End Sub

#If DEBUG Then
    Private Sub LogMessage(ByVal s As String)
        Console.WriteLine(s)
    End Sub
#End If

    Sub DoStuff()
        DoFirstThing()
        LogMessage("Did first thing")
        DoSecondThing()
        LogMessage("Did second thing")
        DoThirdThing()
        LogMessage("Did third thing")
    End Sub
End Class

Are Partial Methods Some Form Of AOP (Aspect Oriented Programming)?

No. Partial methods do share some things in common with Aspect Oriented Programming in that partial methods offer a way of associating "hooks" with custom code. However, unlike AOP systems partial methods require extension points to be explicitly defined by the customer. AOP systems allow developers to "weave in" functionality into code that hasn't had explicit hooks defined. Usually they do this by specifying some declarative search strings that describes the places where the hooks should be applied. The compiler is then responsible for finding all the appropriate "extension points" to apply the hooks to and injecting any necessary method calls. Partial methods in VB do not do this.

New Data Tools Features in Visual Studio Orcas

VBTeam — Tue, 13 Mar 2007 18:09:00 GMT

Here's a list of new data tools features in Visual Studio. I will be discussing each one in more detail in upcoming posts.

Object Relational Designer

The object relational mapping technology lets you map relational databases to objects. Once the mapping is done, you can manipulate mapped objects as normal objects and easily submit changes back to relational database without writing complex data access logic. It is the latest enhancement in data access technology and there are many different implementations out there currently. However, no O/R implementation comes with a graphical designer that makes it easy to create and modify mapping.

The Object Relational Designer in Visual Studio is Microsoft's answer to how O/R mapping should be done. It's a graphical designer which lets you easily map database objects such as tables and stored procedures to LINQ To SQL classes and methods. You can just drag out database objects from the Database Explorer onto the designer. Designer then takes care of creating mapping and generating proper LINQ To SQL code. You can also modify different aspects of mapping through the designer and let the designer take care of updating the code automatically. Association and inheritance relationships can also be easily created easily. The stored procedure support is also a very unique feature. Instead of letting LINQ To SQL generate INSERT, UPDATE and DELETE SQL statements, you can map methods created based on the stored procedures to each behavior.

If you've tried May CTP of LINQ, you probably remember a version of the O/R Designer we included. It was called DLinq Designer. What you see in March CTP of Visual Studio Orcas is the next generation of DLinq Designer and it's now called the O/R Designer.

Hierarchical Update in Typed Dataset

Keeping track of all inserts, updates and deletes across multiple related datatables and sending those changes in the right order back to the server is not an easy task. How do you make sure that new orders for your customer are added correctly to the system while updating the shipping address of the same customer and deleting one of old orders that had been cancelled all at the same time?

With hierarchical update support in Typed Dataset, all you need to do is to call UpdateAll() method of the new TableAdapterManager component we've added. It takes care of collecting all changes and sending them back to the server in the right order. Of course, everything is wrapped into a transaction.

We believe this would significantly improve the productivity of developers using Typed Dataset to create data applications. You can try this new feature in March CTP of Visual Studio Orcas.

N –Tier Support in Typed Dataset

I admit. Typed Dataset code we generate in Visual Studio 2005 is not N-Tier ready. If you open up the code file, you will notice that we've done a great job separating types from data access logic. Dataset and typed datatables are declared in one Typed Dataset class and all TableAdapter classes are declared under a separate namespace. But we generate both sets in one code file. For a lot of applications this is not an issue. But when you are building multi-tiered applications, having them in one file doesn't really help. This exact problem is discussed in detail on Splitting Typed Datasets from TableAdapters blog entry from Steve Lasker. The solution proposed in this blog entry was to open up the generated code and manually copy and paste type declaration out into a new class file. Although this did allow you to use Typed Dataset in N-Tier scenario, it had one major problem. Since you are manually modifying generated code, anytime you make a change to Typed Dataset via Dataset Designer, you have to remember to copy and paste code. That was painful.

In Orcas, you can instruct the designer to generate Dataset portion of the code into another project in your solution. No more manual copy/paste. You can even make changes to Typed Dataset from the designer and it will make sure that updated code is generated into the specified project. You can still choose to stay in 2-Tier model. Designer will continue to generate everything in a single file. When you are ready to take your 2-Tier application to N-Tier, just tell the designer which project is the Dataset project and you are done. It's that simple. A preview of this feature is in March CTP of Visual Studio Orcas and you will be able to try the polished version in Beta 1.

Local Data Cache with SQL Compact Edition

SQL Compact Edition enables many exciting scenarios for developers. The most interesting scenario is to use SQL Compact Edition database file as a local cache of data that do not change often. For instance, your application might keep a list of products in local cache while exchanging order information with remote server. Once in a while, you can synch products list from the remote server but you will mostly use local cache.

Since SQL CE is light-weight database that has very little overhead, it's the perfect candidate for the local cache store. You can use the Sync Service for ADO.NET to synchronize data between remote database server and local SQL CE database file. Sounds great, right? But how do you set everything up so that you can do this?

Visual Studio Orcas includes new project item template "Local Data Cache". Adding "Local Data Cache" to your project creates .sync file which is an XML file that describes what gets synched and how. This file comes with the designer that lets you configure different aspects of synchronization easily. Designer also creates SQL CE .sdf database file to be used as local cache store as well as synchronization code necessary to interact with the Sync Service. A preview of this feature is in March CTP of Visual Studio Orcas and you will be able to try the polished version in Beta 1.

Other Enhancements to Data Tools

Above four are major data tools features in Visual Studio Orcas. But there are tons of other enhancements we've made to existing data tools. I will be dedicating a separate post to describe other important enhancements we've made.