{"id":5163,"date":"2007-11-21T01:24:16","date_gmt":"2007-11-21T01:24:16","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2007\/11\/21\/hidden-gems-in-visual-basic-2008-amanda-silver\/"},"modified":"2024-07-05T14:38:06","modified_gmt":"2024-07-05T21:38:06","slug":"hidden-gems-in-visual-basic-2008-amanda-silver","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/hidden-gems-in-visual-basic-2008-amanda-silver\/","title":{"rendered":"Hidden Gems in Visual Basic 2008 (Amanda Silver)"},"content":{"rendered":"

Yesterday I promised to post<\/a> 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<\/a> 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 <\/i>stuff.<\/p>\n

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 <\/i>talk about – but you’re going to have to check back. But first, I have to start with a keynote feature… <\/p>\n

0) <\/b>Multi-targetting<\/b><\/h5>\n

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. <\/p>\n

\"clip_image002\"<\/a><\/p>\n

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. <\/p>\n

1) <\/b>Type Inference<\/b><\/h5>\n

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.<\/p>\n

        Dim<\/span> dialog = New<\/span> OpenFileDialog()\n        Dim<\/span> result = dialog.ShowDialog()\n        Dim<\/span> printStr = "C:"\n<\/span>        If<\/span> result = Windows.Forms.DialogResult.OK Then\n<\/span>            printStr = dialog.FileName\n        End<\/span> If\n<\/span>        MsgBox(printStr)<\/pre>\n
<\/a><\/p>\n
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<\/a>. <\/p>\n
2) <\/b>If Operator<\/b><\/h5>\n
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<\/i> on type-safe, early-bound code, you have to cast<\/i> the result. The code then looks something like this:<\/p>\n
        Dim<\/span> intC As<\/span> Integer<\/span> = CInt<\/span>(IIf(intA = intB, intA, intB - 1))<\/pre>\n
With the If operator, you can now write that line as:<\/p>\n
        Dim<\/span> intD As<\/span> Integer<\/span> = If<\/span>(intA = intB, intA, intB)<\/pre>\n
<\/a><\/p>\n
And with type inference it gets even easier on the eyes:<\/p>\n
\"clip_image004\"<\/a><\/p>\n
I’m a fan of any feature that improves readability. <\/p>\n
3) <\/b>Object Initializers<\/b><\/h5>\n
Generally, in the .NET frameworks, we try to design APIs that use the create-set-call pattern<\/a> 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:<\/p>\n
        Dim<\/span> strm As<\/span> New<\/span> StreamWriter( _\n                      New<\/span> FileStream("C:out.txt"<\/span>, FileMode.OpenOrCreate) _\n                        With<\/span> {.Position = 10})<\/pre>\n
<\/a><\/p>\n
It also makes creating arrays of objects much easier. <\/p>\n
        Dim<\/span> Capitals() As<\/span> City = {New<\/span> City With<\/span> {.Name = "Antanarivo"<\/span>, .Country = "Madagascar"<\/span>}, _\n          New<\/span> City With<\/span> {.Name = "Belmopan"<\/span>, .Country = "Belize"<\/span>}, _\n          New<\/span> City With<\/span> {.Name = "Monaco"<\/span>, .Country = "Monaco"<\/span>}, _\n          New<\/span> City With<\/span> {.Country = "Palau"<\/span>, .Name = "Koror"<\/span>}}<\/pre>\n
<\/a><\/p>\n
<\/b><\/p>\n
4) <\/b>Nullable <\/b><\/h5>\n
Nullable is the feature you’ll notice but rarely have to think about. It’s basically the .NET representation for a Nullable value type<\/a> (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 – <\/i>null valued rows propagate null. In the example below, the Independence property on the Country type is a nullable date, denoted as Date<\/span>?<\/p>\n
<\/a><\/p>\n
        Dim<\/span> virginIslands As<\/span> New<\/span> Country With<\/span> {.Independence = Nothing<\/span>}\n        Dim<\/span> palau As<\/span> New<\/span> Country With<\/span> {.Independence = #10\/1\/1994#}\n        Dim<\/span> vILength = #8\/24\/2005# - virginIslands.Independence ' Nothing\n<\/span>        Dim<\/span> pLength = #8\/24\/2005# - palau.Independence ' 3980.00:00:00<\/span><\/pre>\n
<\/a><\/p>\n
<\/b><\/p>\n
5) <\/b>LINQ to DataSet <\/b><\/h5>\n
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:<\/p>\n
        Me<\/span>.EmployeesTableAdapter.Fill(Me<\/span>.NORTHWNDDataSet.Employees)\n        Dim<\/span> query = From<\/span> emp In<\/span> Me<\/span>.NORTHWNDDataSet.Employees _\n                    Where<\/span> emp.Country = "USA"<\/span> _\n                    Order<\/span> By<\/span> emp.HireDate _\n                    Select<\/span> emp\n        Me<\/span>.EmployeesBindingSource.DataSource = query<\/pre>\n
<\/a><\/p>\n
<\/b><\/p>\n
6) <\/b>Syntax Tooltips<\/b><\/h5>\n
How cool is this?<\/p>\n
\"clip_image006\"<\/a><\/p>\n
How about this?<\/p>\n
\"clip_image008\"<\/a><\/p>\n
What do you think of this?<\/p>\n
\"clip_image010\"<\/a><\/b><\/b><\/p>\n
<\/b><\/p>\n
7) <\/b>XML Namespace support in Intellisense<\/b><\/h5>\n
We’ve blogged<\/a> about XML Intellisense<\/a> before. But there’s a tidbit we’ve overlooked. <\/p>\n
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:<\/p>\n
\"clip_image012\"<\/a><\/p>\n
If we just type the letter “t” the “tomato” entry will be selected:<\/p>\n
\"clip_image014\"<\/a><\/p>\n
If we type the letter “e” the “exa:eggplant” will be selected and the completion list will also<\/i> contain the prefix “exa” and the “elephant” entry:<\/p>\n
\"clip_image016\"<\/a><\/p>\n
 The next character that will be typed will determine which single entry will get selected. Now, how easy was that?<\/p>\n
<\/h5>\n
8) <\/b>GoTo Type Definition<\/b><\/h5>\n
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. <\/p>\n
\"clip_image018\"<\/a><\/b> <\/b><\/p>\n
<\/b><\/p>\n
9) <\/b>Type inference for loop variables<\/b><\/h5>\n
Check out the following code:<\/p>\n
\"clip_image020\"<\/a><\/p>\n
And this code:<\/p>\n
\"clip_image022\"<\/a><\/p>\n
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. <\/p>\n
10) <\/b>Performance improvements and… Non-blocking operations!<\/b><\/h5>\n
The background compiler is an awesome<\/i> feature that gives you immediate feedback on the correctness of the code you write. We’ve made some tremendous<\/a><\/i> 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.<\/p>\n
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:<\/p>\n
\"clip_image024\"<\/a><\/p>\n
The IDE will still be responsive. <\/b><\/p>\n
Now do you have to download it<\/a>? Remember, you can always grab the Express<\/a> Edition!<\/p>\n","protected":false},"excerpt":{"rendered":"
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 […]<\/p>\n","protected":false},"author":260,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[21,195],"tags":[28,67,74,77,94,117,164,166],"class_list":["post-5163","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-im-a-vb","category-visual-basic","tag-amanda-silver","tag-extension_methods","tag-ide","tag-iqueryable","tag-linqvb9","tag-orcas","tag-vb_express","tag-vb2008"],"acf":[],"blog_post_summary":"
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 […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/5163","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/260"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=5163"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/5163\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=5163"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=5163"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=5163"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
<\/a><\/p>\n