The Visual Basic Team : Amanda Silver

VSLive San Francisco Content (Amanda Silver)

VBTeam — Tue, 01 Apr 2008 00:19:26 GMT

All - I'm about to go on for my LINQ Deep Dive and Tips &Tricks session at VSLive in San Francisco. I posted all demos & slides here:

https://code.msdn.microsoft.com/Release/ProjectReleases.aspx?ProjectName=LaunchVB&ReleaseId=805

Awesome VB9 Blog Series by Bart De Smet (Amanda Silver)

VBTeam — Wed, 21 Nov 2007 13:48:42 GMT

I guess I've been working too hard on getting the product ready to ship to notice that Bart has put together an awesome blog series on VB9.

It includes discussion of a feature called runtime agility or compiler agility that we haven't taken up on this blog. We introduced this feature to make it much easier for new .NET platforms (think Silverlight, XNA, & .NET Micro Frameworks) to allow Visual Basic programmers to target their platform. For those of you language/compiler wonks or VB zen masters -- this is a good feature to learn about as it gives you insight into the dependencies the Visual Basic compiler has on the Microsoft.VisualBasic.dll aka VBRuntime. For the mavericks, Bart talks about compiling his own version of the VB runtime that contains just the features he wants (CompareString). But this feature is designed to be a transparent implementation detail of the Visual Basic tool for those of you that are just interested in getting your job done. Enjoy!

Hidden Gems in Visual Basic 2008 (Amanda Silver)

VBTeam — Wed, 21 Nov 2007 09:24:16 GMT

Yesterday I promised to post about the hidden gems in Visual Basic and Visual Studio 2008 that you haven’t read about in blog posts or seen at conferences. I forgot that I mentioned a few of my favorite features in the Beta1 announcement where I showed off the improvements in the Intellisense experience – statement completion for keywords, local variables, and expressions. In that post, I also cover a new language feature called Relaxed Delegates which allows you to provide alternate signatures for events. Both of those are pretty great features – but I promised to tell you about some new stuff.

I polled the team and we came up with the following top ten that weren’t mentioned in my previous post. There’s so much I could talk about – but you’re going to have to check back. But first, I have to start with a keynote feature…

0) Multi-targetting

In short, multi-targetting allows you to use Visual Studio 2008 (and VB 9!) to target the .NET 2.0 frameworks. All of the following features I’ll show you can be leveraged even if you’re targeting .NET 2.0! (With the exception of items #5 & #7 as they depend on the LINQ to Objects and LINQ to XML APIs which reside in .NET 3.5) To do this, when you start up Visual Studio and create a new project, just make sure that the target framework is set to .NET Framework 2.0.

Note that projects you’re upgrading, will automatically target .NET Framework 2.0 until you add references to .NET 3.0 or 3.5 assemblies.

1) Type Inference

In Visual Basic 9, in the following bit of code and NOTHING is late-bound – everything is bound at compile-time which means you get Intellisense and type checking.

        Dim dialog = New OpenFileDialog()
        Dim result = dialog.ShowDialog()
        Dim printStr = "C:\"
        If result = Windows.Forms.DialogResult.OK Then
            printStr = dialog.FileName
        End If
        MsgBox(printStr)

This makes prototyping very quick, easy, and type-safe! This feature and the mechanisms that control it are comprehensively covered in this article by a member of our QA team, Bill Horst.

2) If Operator

Ever notice that the IIF function returns something of type Object? This means that you don’t get Intellisense or type-checking by default on that result. For those of you that insist on type-safe, early-bound code, you have to cast the result. The code then looks something like this:

        Dim intC As Integer = CInt(IIf(intA = intB, intA, intB - 1))

With the If operator, you can now write that line as:

        Dim intD As Integer = If(intA = intB, intA, intB)

And with type inference it gets even easier on the eyes:

I'm a fan of any feature that improves readability.

3) Object Initializers

Generally, in the .NET frameworks, we try to design APIs that use the create-set-call pattern as our usability studies have indicated they are the easiest to use by the average programmer. Nevertheless, objects that don’t have a parameterless constructor exist in the .NET framework. When that happens, it’s really nice to be able to leverage Object Initializers which are kind of like a Dim and a With statement combined into an expression. That makes parameterized constructors somewhat easier to tolerate:

        Dim strm As New StreamWriter( _
                      New FileStream("C:\out.txt", FileMode.OpenOrCreate) _
                        With {.Position = 10})

It also makes creating arrays of objects much easier.

        Dim Capitals() As City = {New City With {.Name = "Antanarivo", .Country = "Madagascar"}, _
          New City With {.Name = "Belmopan", .Country = "Belize"}, _
          New City With {.Name = "Monaco", .Country = "Monaco"}, _
          New City With {.Country = "Palau", .Name = "Koror"}}

4) Nullable

Nullable is the feature you’ll notice but rarely have to think about. It’s basically the .NET representation for a Nullable value type (Integer, Date, etc.) Using the designer for LINQ to SQL, the Object-Relational Mapping layer introduced in Visual Studio 2008, nullable columns in your database are mapped to this type. The result is that you can write the following expression in VB and the right thing happens – null valued rows propagate null. In the example below, the Independence property on the Country type is a nullable date, denoted as Date?

        Dim virginIslands As New Country With {.Independence = Nothing}
        Dim palau As New Country With {.Independence = #10/1/1994#}

        Dim vILength = #8/24/2005# - virginIslands.Independence ' Nothing
        Dim pLength = #8/24/2005# - palau.Independence ' 3980.00:00:00

5) LINQ to DataSet

I love this feature because it means never having to say you’re sorry… No, really, it means that you don’t need to migrate to a new data access technology to reap the benefits of LINQ. I fill my DataSet just as before, and then I can query against the DataSet:

        Me.EmployeesTableAdapter.Fill(Me.NORTHWNDDataSet.Employees)
        Dim query = From emp In Me.NORTHWNDDataSet.Employees _
                    Where emp.Country = "USA" _
                    Order By emp.HireDate _
                    Select emp
        Me.EmployeesBindingSource.DataSource = query

6) Syntax Tooltips

How cool is this?

How about this?

What do you think of this?

7) XML Namespace support in Intellisense

We’ve blogged about XML Intellisense before. But there’s a tidbit we’ve overlooked.

When namespaces are used in the XML document you’re reading from, the Intellisense engine matches the namespace prefix and the local name. This little productivity boost can yield a significant savings in keystrokes. Instead of typing the prefix then the colon and then the local name, you just type a little bit of the local name and hit enter. Here is a small example of how it works, starting with an input document and the applicable intellisense:

If we just type the letter “t” the “tomato” entry will be selected:

If we type the letter “e” the “exa:eggplant” will be selected and the completion list will also contain the prefix “exa” and the “elephant” entry:

The next character that will be typed will determine which single entry will get selected. Now, how easy was that?

8) GoTo Type Definition

Often, when you define a variable, you want to view the type definition in code or in the Object Browser. There’s a new option in the context menu which allows you to go directly to the type definition instead of just the variable declaration. This is great when combined with type inference as it allows you confirm that the type of the variable is actually what you believe it to be.

9) Type inference for loop variables

Check out the following code:

And this code:

Without having to specify the type of the control variable, it’s inferred from right-hand-side expression or the collection we’re iterating over.

10) Performance improvements and… Non-blocking operations!

The background compiler is an awesome feature that gives you immediate feedback on the correctness of the code you write. We’ve made some tremendous strides in the performance of the background compiler in this release. We believe that the background compiler is 3 times faster uses 3 times less memory. Anyone who has migrated their project to 2008 should notice an improvement after a couple minutes of use.

While we’ve made huge improvements on the throughput, certain operations like changing the declaration of a base class that’s used many times in a large project is computationally expensive. If you attempted to invoke a feature that relied on compiled information before the background compiler has a chance to do its magic, like Intellisense or the Drop Downs, previous versions of Visual Studio would grind to a halt until the compilation was complete. Those operations are no-longer blocking. So, while you might occasionally get the drop downs to look like this:

The IDE will still be responsive.

Now do you have to download it? Remember, you can always grab the Express Edition!

Visual Basic 2008 Ships!!! (Amanda Silver)

VBTeam — Mon, 19 Nov 2007 20:27:00 GMT

Hooray! Today we’ve finally shipped Visual Studio 2008, previously known as “Orcas”, previously known as some symbol which doesn’t have an ascii representation. We’ve come a long way, but it’s been a great ride. In his blog, Soma mentions many of the flagship features at a high-level that will undoubtedly make the every developer and head of IT salivate, but this blog is about Visual Basic. :)

This is a tremendous release for Visual Basic users everywhere as it’s the first to introduce query expressions and XML as a first class data-type. Not only does this make Visual Basic the most productive choice for programming data-centric applications, it also makes us VB developers the envy of many an alpha-geek. If you'd like to just try it out -- be sure to check out Visual Basic Express which comes with all the features I talk about below.

With query the entire .NET frameworks become a queryable data source. You can now query against anything available in the .NET Frameworks – the registry, file system, live processes, etc. For example, the code below queries against the running processes and returns those with a thread count greater than 10, orders them by the thread count:

        Dim query = From proc In Process.GetProcesses _
            Let ThreadCount = proc.Threads.Count _
            Where ThreadCount > 10 _
            Order By ThreadCount _
            Select proc.ProcessName, proc.Id, ThreadCount

Using the LINQ to SQL Object-Relational Mapping framework, you can query against a SQL database as though it was just another collection of objects exposed by the frameworks. The following query finds all the products that have been discontinued, groups them into categories, and finds the total number of units in stock for each category:

        Dim db As New NorthwindDataContext(My.Settings.NORTHWNDConnectionString)
        Dim query = From prod In db.Products _
                    Where prod.Discontinued = True _
                    Group By prod.CategoryID _
                    Into Count(), NumInStock = Sum(prod.UnitsInStock) _
                    Join cat In db.Categories On cat.CategoryID Equals CategoryID _
                    Select cat.CategoryName, Count, NumInStock

Unlike writing huge SQL query strings, I get immediate feedback on the query I write.

Intellisense:

Syntax checking:

Schema checking:

I can use the same query language (VB!) to query against relational databases, XML, and collections of objects – I don’t need to learn any domain specific language, VB gives me access to all! It’s really easy for me to join across domains (I’ll take that up in a later blog post.)

With XML as a first class data-type, Visual Basic becomes a full XML transform language. But it’s also really easy for me to project to XML from my SQL database:

        Dim query = From prod In db.Products _
            Where prod.Discontinued = True _
            Group By prod.CategoryID _
            Into prodGroup = Group, NumInStock = Sum(prod.UnitsInStock) _
            Join cat In db.Categories On cat.CategoryID Equals CategoryID _
            Select <Products>
                       <Category CategoryID=<%= CategoryID %> CategoryName=<%= cat.CategoryName %>>
                           <%= From prod In prodGroup _
                               Select <Product Price=<%= prod.UnitPrice %>><%= prod.ProductName %></Product> %>
                       </Category>
                   </Products>

Last but not least, for those of you who aren’t so excited about the LINQ (Language INtegrated Query) project, Visual Basic 2008 comes with a tremendous improvement in the Intellisense experience overall. One of our MVPs said that he literally types two characters and hits tab, two characters, tab – it’s as though the code writes itself!

Obviously, we’re very excited about this release and hope it meets you with open arms eager to embrace the productivity! If you're ready to go to the next level and dig in, be sure to check out our learning pages and How-Do-I videos which walk you through these features and so much more.

Tomorrow I’ll blog about the least often mentioned goodies hidden in Visual Basic 2008 so that you can become the guru master of VB9. ‘Til then…

Channel 9 Interview - Amanda Silver on LINQ (Beth Massi)

VBTeam — Fri, 17 Aug 2007 22:24:00 GMT

I just posted an interview with Amanda on Channel 9 where she walks us through the new LINQ syntax available in VS 2008 Beta 2. I also posted some How Do I videos on LINQ to help get you started -- look for more of these beginning of next week!

In this interview, Amanda Silver, a Lead Program Manager on the Visual Basic Team, demonstrates new LINQ syntax around Joins and Aggregates that is now available in Visual Studio 2008 Beta 2. Amanda is a guru of LINQ in Visual Basic and gives insightful explanations of how to use this new syntax.

The interview starts out a little funny because the first 20 seconds of my video tape got chewed up so we had to reshoot the intro later in the day. Amanda thought of a funny way to make the transition as you'll see. See if you can pinpoint the movie that inspired her!

Enjoy!
- Beth Massi, VS Community

Amanda Silver will be Presenting VB and Silverlight on Second Life! (Beth Massi)

VBTeam — Mon, 30 Jul 2007 21:43:00 GMT

If you haven't seen or experienced Second Life it's pretty amazing. It's an online, 3D, digital world. Visual Studio has created an island where you can come listen to live Microsoft presenters in this virtual world's live presentation theater! Amanda Silver will be presenting Visual Basic on Silverlight tomorrow, July 31st at 4pm Pacific time. There's a lot of other fun events you should check out as well.

See you there!

-Beth Massi, VS Community

Lambdas, and Take While, and Group By, Oh My!

VBTeam — Thu, 26 Jul 2007 20:02:00 GMT

Hooray! Visual Basic 2008 Beta2 has been released to the wild today to return to its natural habitat – the desktops of our beloved customers. (Please note our smiling GPM's face on that landing page -- he's so happy the Beta is done.)

What’s inside? So much that there might be more new features than we released in Beta1, but who’s counting? Here’s a laundry list that’s specific to the VB language that’s new for Beta2:

· Query operators

o Group By, Group Join, Join, Take [While], Skip [While], Aggregate, Count, Sum, Min, Max, Average, From à Let

· Nullable support

· Lambda Expressions (aka Inline Functions)

· Partial Methods – ScottGu mentioned this the other day & ScottWis posted a couple weeks back

· Anonymous Types w/Keys – Which PaulV has already discussed

Here are a bunch of queries you can now write with VB!

' Find suppliers in the same city as customers

From cust In db.Customers _

Join sup In db.Suppliers _

On cust.City Equals sup.City _

Select cust.CompanyName, sup.ContactName, cust.City

' Find suppliers in the same city, with the same postalcode as customers

From cust In db.Customers _

Join sup In db.Suppliers _

On cust.City Equals sup.City And cust.PostalCode Equals sup.PostalCode

Select cust.CompanyName, sup.ContactName, cust.City

' Find the average unit price and count for products by category

From prod In db.Products _

Group By prod.CategoryID _

Into Average(prod.UnitPrice), Count()

' For each customer find the group of the suppliers in the same country

From cust In db.Customers _

Group Join sup In db.Suppliers _

On cust.Country Equals sup.Country _

Into SuppliersInCountry = Group _

Select cust.CompanyName, SuppliersInCountry

' For each customer, the count of the number of suppliers in the same country

From cust In db.Customers _

Group Join sup In db.Suppliers _

On cust.Country Equals sup.Country _

Into NumSuppliers = Count() _

Select cust.CompanyName, NumSuppliers

' Avg price, avg # in stock, and max on order for non-discontinued products

Aggregate prod In db.Products _

Where Not prod.Discontinued _

Into AvgPrice = Average(prod.UnitPrice), _

AvgInStock = Average(prod.UnitsInStock), _

MaxOnOrder = Max(prod.UnitsOnOrder)

' Find orderID, OrderDate, and OrderTotal for each order

From order In db.Orders _

Where order.OrderDate > #7/22/1996# _

Aggregate ordDet In order.Order_Details _

Into OrderTotal = _

Sum(ordDet.UnitPrice *ordDet.Quantity * (1 - ordDet.Discount))

Select order.OrderID, order.OrderDate, OrderTotal

' Fill a dictionary with the customers by CompanyName

db.Customers.ToDictionary(Function(cust As Customer) cust.CompanyName)

In addition to all the new language support, we now have keyword Intellisense (finally!)

We have XML Intellisense! What?? That’s right.

And we’ve done some major performance improvements for the background compiler – let us know if you experience any sluggishness for this Beta. (BTW, you should check out Scott's post on Beta2 to avoid some problems with AJAX extensions if you're installing to a machine that has had previous versions of Orcas installed on it or has VS 2005 side by side.)

Also, don’t forget to look for other exciting features around the product that pertain to VB and/or LINQ. For example, Linq to SQL now supports the Like operator! There’s also a new ASP:LinqDataSource control.

So, get the bits while they’re hot!

-Amanda

Slide Deck for Conquering XML with LINQ to XML Webcast [Beth Massi]

VBTeam — Fri, 06 Jul 2007 02:22:00 GMT

Amanda Silver gave a great webcast Tuesday morning on LINQ to XML (if you missed it, just click the link and view it on-demand). Here is the deck she used.

Happy LINQing!

-Beth Massi, Program Manager VS Community

Today's Live From Redmond Webcast Rescheduled [Beth Massi]

VBTeam — Wed, 27 Jun 2007 17:34:00 GMT

Amanda Silver came down with a nasty sickness last night so we just had to reschedule her Live From Redmond: VB9 - Conquering XML with LINQ to XML talk for this Tuesday July 3rd. If you're already registered then you're good to go for next week and automated emails should have been sent out to notify you all of the change. If you haven't registered yet, what are you waiting for? :-)

Sincerest apologies from Amanda -- and we hope she feels better very soon!

Live From Redmond Webcast Just Added on LINQ to XML (Beth Massi)

VBTeam — Thu, 14 Jun 2007 04:40:00 GMT

Back by popular demand! Amanda Silver will be presenting Live From Redmond: VB9 - Conquering XML with LINQ to XML on June 27th.

In Visual Basic 9.0, XML becomes a built-in data type with a rich editing experience that completely eliminates the conceptual barrier between the code that you write and the XML that you’re trying to express. Amanda will take you from the guts of the LINQ to XML API to the easy to grasp abstractions presented in Visual Basic 9.0. It will cover tips, tricks, and gotchas so that you reach peak performance when programming against XML with Visual Basic 9.0.

Hope to see you at the Webcast!

For more webcasts, past, present and future please visit the Visual Basic Webcast page.

-Beth Massi, Program Manager VS Community

Visual Basic XML Transform - TechEd demo prep

VBTeam — Wed, 06 Jun 2007 19:13:00 GMT

Hello from Orlando! I’ve been at TechEd 2007 this week in very sunny Orlando. As part of my demo prep, I had to create a little xml transform to convert the TechEd schedule that I got off the www.msteched.com website in an Excel XML format into a more readable xml file format. I could have done this all with one transform, but the newer XML file format made for good demo fodder to show off the XML Intellisense features coming in Orcas Beta2.

I thought the code was interesting and fun – a great blend of XML properties, XML Literals, and query – so I’ve posted it below:

Imports System.IO

Imports <xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">

Module Module1

'Metadata info

Enum Column

Code

Title

Description

Track

Session

Level

Speaker

Room

Timeslot

End Enum

Sub Main()

Dim fromFile = "C:\TechEdScheduleExcelFormat.xml"

Dim toFile = "C:\MyXMLFormat.xml"

Dim excelXML = XElement.Load(fromFile)

' Remove first row - metadata info

excelXML...<ss:Row>.First.Remove()

Dim xml = _

<?xml version="1.0"?>

<%= _

From session In excelXML...<ss:Row> _

Let info = session...<ss:Data> _

Select _

</Event> _

</EventSchedule>

xml.Save(toFile)

Shell("C:\Program Files\Internet Explorer\iexplore.exe " & toFile, AppWinStyle.MaximizedFocus)

End Sub

End Module

All this, so that in the demo, I could:

1) Open the resulting file, “MyXMLFormat.xml”, in Visual Studio

2) Right click on the XML menu item

3) Select create schema to infer an XSD from that file:

4) Save the schema as an XSD and add it as an existing item in my project:

5) And get an awesome Intellisense experience over the XML:

Pretty cool, no?

Bill & Steve (Jobs!) reminisce about floating point BASIC

VBTeam — Thu, 31 May 2007 20:07:00 GMT

Another entry in the annals of BASIC history today…. Bill Gates and Steve Jobs sat down for an interview with Kara Swisher and Walt Mossberg of All Things Digital for the D5 conference. One of the highlights of the video is recalling the agreement Apple struck with Microsoft for a version of BASIC which supported floating point numbers. Apparently, Steve begged Steve Wozniak to implement such a version of BASIC, eventually licensed a version that supported floating point numbers from Microsoft, and then released it as Applesoft BASIC in 1979. Watching them tell the story is like having your parents tell you how they met – kind of gross, but endearing.

AmandaS' LINQ talk at VSLive Orlando

VBTeam — Tue, 08 May 2007 08:21:00 GMT

I escaped from Redmond this week to present at VSLive Orlando on LINQ in Visual Studio Orcas. As promised, please find the slides and demos included as an attachment below.

As mentioned during the talk – that was intended to be an overview. If you want really want to understand the nitty-gritty details behind what make LINQ possible, be certain to tune into my LINQ Deep Dive WebCast on May 23^rd. If you’d like me to go into something specific during the webcast, just respond to this post. I can’t promise to get to everything in the webcast itself, but I do promise to answer any LINQ related questions in response to this post or the webcast. Be sure to pose questions to the LINQ forum if you think others might be able to help or have the same question.

I had a great time at VSLive today, I hope you enjoyed it as much as I did. I’m looking forward to TechEd!

Four dynamic languages for .NET interoperating!

VBTeam — Wed, 02 May 2007 21:06:00 GMT

John Lam just posted a screen cast of four dynamic languages interoperating in SIlverlight on the Mac! Check it out!

What do the announcements at Mix mean for the Visual Basic developer?

VBTeam — Tue, 01 May 2007 08:52:00 GMT

At the Mix conference today in Las Vegas, Ray Ozzie and Scott Guthrie were dropping goodies like tootsie pops from a piñata. There was so much packed into their over two hour keynote that I thought it would be useful to distill the announcements down into one bite-sized post that should make for a pretty quick read (but unfortunately, includes no code samples.)

- VB on Silverlight – In short, this means that you can now use Visual Basic as the code-behind for whiz-bang rich interactive applications that run on Windows or the Mac and can run in IE, Firefox, and Safari. You can download the alpha .NET-enabled release but to develop you will need the Visual Studio Extensions for Silverlight for “Orcas” Beta1.

- Unparalleled support for dynamic languages – As you may have noticed us hinting at over the past couple of years now, VB has certain aspects to it that are dynamic – late binding, explicit member indexing, runtime conversions and operators, etc. With Silverlight comes the introduction of the DLR, a shared runtime component for dynamic languages atop .NET. There are many, many, things this means for VB that will unfold over the coming months, but one of the most important ones is that it will enable simple interoperability between Visual Basic and the other dynamic languages on .NET like Ruby, Python, and JScript.

- Live Services – The Live Services team has created Windows Live in a Box that will allow you to begin integrating rich photo experiences, search, contacts and more into your applications.

- Productivity Frameworks – Scott and Ray didn’t talk about this in their keynote, but with Mix comes a couple of new productivity frameworks. The first is Dynamic ASP.NET controls which uses runtime database schema and coding conventions to data-bind and generate ASP.NET pages. The second is “Jasper”, a dynamic data access layer that is independent of a presentation technology which sits atop the Entity Framework. We’re looking forward to seeing the reception for these kinds of frameworks.

So, that’s the two-bite version of the announcements… Over the next couple of weeks we’ll post new entries, videos, and samples demonstrating what each of these means in detail – though for some dirty details, you’ll have to wait for the PDC.

I’ll be at VSLive next week to talk about LINQ and Integrated XML in VB Orcas. I also have my turn for the webcast series for the VB LINQ deep dive and TechEd not that shortly after I get back – so I’ve got some work to do! Enough overview, back to coding!