{"id":353,"date":"2012-02-28T18:18:00","date_gmt":"2012-02-28T18:18:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2012\/02\/28\/visual-basic-11-beta-available-for-download\/"},"modified":"2024-07-05T12:38:57","modified_gmt":"2024-07-05T19:38:57","slug":"visual-basic-11-beta-available-for-download","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/visual-basic-11-beta-available-for-download\/","title":{"rendered":"Visual Basic 11 Beta Available for Download!"},"content":{"rendered":"<\/p>\n

As you may have read in Jason’s announcement<\/a>, today we announced that Visual Studio 11 Beta is now available for download<\/a>.  This is a huge<\/i><\/b> <\/i>release for Visual Basic as it provides full platform support for building Windows 8 Metro style apps, a first-class asynchronous programming experience, and also the long-awaited Iterators<\/i> feature.  And in the true spirit of VB, you’ll see a ton of other improvements that will make you more productive every day.<\/p>\n

 <\/p>\n

Async
<\/b>As the world moves to mobile phones and tablets, the demand for responsiveness in today’s applications is higher than ever.  Things like database queries, network requests, and disk access all have potential to block the UI and leave users frustrated.  While user expectations continue to climb, the tool\/platform support for making asynchronous programming easy hasn’t kept pace, until now.  With the new Async\/Await keywords, VB11 makes asynchronous programming really simple: <\/p>\n

   <\/span>Public<\/span> <\/span>Async<\/span> <\/span>Function<\/span> GetStorageFile() <\/span>As<\/span> <\/span>Task<\/span>(<\/span>Of<\/span> Windows.Storage.<\/span>StorageFile<\/span>)<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Dim<\/span> packageFolder = Windows.ApplicationModel.<\/span>Package<\/span>.Current.InstalledLocation<\/span><\/p>\n

 <\/span><\/p>\n

        TextBlock1.Text = <\/span>“Retrieving File…”<\/span><\/span><\/p>\n

<\/span><\/span><\/p>\n

        <\/span>Dim<\/span> packagedFile = <\/span>Await<\/span> packageFolder.GetFileAsync(<\/span>“FileLocatedInPackage”<\/span>)<\/span><\/p>\n

        <\/span>..<\/span>.<\/span><\/p>\n

        <\/span>Return<\/span> packagedFile<\/span><\/p>\n

    <\/span>End<\/span> <\/span>Function<\/span><\/p>\n

 <\/p>\n

The Await keyword kicks off an asynchronous request without blocking the UI.  The function returns a Task(Of T) at the point of the Await expression, but this is just a placeholder for the return value that will come from GetFileAsync.  Once that work completes, the method resumes<\/i> and the variable packagedFile is assigned to. <\/p>\n

Be sure to check out the Asynchronous Programming Developer Center<\/a> for articles, videos, and samples on how to use Async.  This blog post<\/a> has a good conceptual explanation of async, and Lucian’s blog<\/a> has a ton of great resources for learning the feature. <\/p>\n

VB11 also includes full async debugging support.  F10-Step-Over (or Shift+F8 on VB Profile) now does what you’d expect.  If you’re still on the function-declaration-line then it steps out to the caller. But often (e.g. if you’ve gone past an await) then the concept of “caller” doesn’t even exist. So, for consistency, if you’re anywhere outside the declaration line then Shift+F11 (Ctrl+Shift+F8 on VB Profile) will step out to someone who’s awaiting you. <\/p>\n

The other thing we’ve added is async unit-testing support in MSTest.  xUnit now supports this as well.<\/p>\n

 <\/span><\/p>\n

    <TestMethod<\/span>><\/span><\/p>\n

    Async<\/span> Function<\/span> Test1() As<\/span> Task<\/span><\/span><\/p>\n

        Dim<\/span> x = Await<\/span> Engine.GetSevenAsync() <\/span><\/p>\n

        Assert<\/span>.AreEqual(x, 6) <\/span><\/p>\n

    End<\/span> Function<\/span><\/span><\/p>\n

 <\/span><\/p>\n

    <Xunit.Fact<\/span>><\/span><\/p>\n

    Async<\/span> Function<\/span> Test2() As<\/span> Task<\/span><\/span><\/p>\n

        Dim<\/span> x = Await<\/span> Engine.GetSevenAsync()<\/span><\/p>\n

        Xunit.Assert<\/span>.Equal(x, 6)<\/span><\/p>\n

    End<\/span> Function<\/span><\/span><\/p>\n

 <\/span><\/p>\n

<\/span> <\/p>\n

Iterators
<\/b>Iterators<\/a> are a new feature in VB11 that make it easier to walk through collections such as lists and arrays.  Each element is returned to the calling method immediately, before the next element in the sequence is accessed. <\/p>\n

 In addition to working with collections, you can use iterators to write your own custom LINQ query operators.  For instance, the following example prints out only the even numbers in the array: <\/p>\n

Module<\/span> <\/span>Module1<\/span><\/p>\n

 <\/span><\/p>\n

    <\/span>Sub<\/span> Main()<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Dim<\/span> query = <\/span>From<\/span> n <\/span>In<\/span> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}<\/span><\/p>\n

                    <\/span>Where<\/span> n <\/span>Mod<\/span> 2 = 0<\/span><\/p>\n

                    <\/span>Select<\/span> n<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>For<\/span> <\/span>Each<\/span> item <\/span>In<\/span> query<\/span><\/p>\n

            <\/span>Console<\/span>.WriteLine(item)<\/span><\/p>\n

        <\/span>Next<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Console<\/span>.ReadLine()<\/span><\/p>\n

 <\/span><\/p>\n

    <\/span>End<\/span> <\/span>Sub<\/span><\/p>\n

 <\/span><\/p>\n

    <System.Runtime.CompilerServices.<\/span>Extension<\/span>><\/span><\/p>\n

    <\/span>Iterator<\/span> <\/span>Function<\/span> Where(source <\/span>As<\/span> <\/span>Integer<\/span>(), <\/span><\/p>\n

                            predicate <\/span>As<\/span> <\/span>Func<\/span>(<\/span>Of<\/span> <\/span>Integer<\/span>, <\/span>Boolean<\/span>)<\/span><\/p>\n

                           ) <\/span>As<\/span> <\/span>IEnumerable<\/span>(<\/span>Of<\/span> <\/span>Integer<\/span>)<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>For<\/span> <\/span>Each<\/span> num <\/span>In<\/span> source<\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>If<\/span> predicate(num) <\/span>Then<\/span><\/p>\n

 <\/span><\/p>\n

                <\/span>Console<\/span>.WriteLine(<\/span>“Yielding “<\/span> & num)<\/span><\/p>\n

                <\/span>Yield<\/span> num<\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>End<\/span> <\/span>If<\/span><\/p>\n

        <\/span>Next<\/span><\/p>\n

 <\/span><\/p>\n

    <\/span>End<\/span> <\/span>Function<\/span><\/p>\n

 <\/span><\/p>\n

End<\/span> <\/span>Module<\/span><\/p>\n

 <\/p>\n

Note the new Iterator<\/i> and Yield<\/i> keywords in the Where function.  (The LINQ query binds to this Where extension method since it’s a better match than the Where(Of T) operator defined in the standard query operators).<\/p>\n

 VB also allows iterator lambdas!<\/strong>  In this example, we use an iterator in an expression context and combine it in a powerful way with XML Literals (note that we’re effectively embedding statements<\/i> inside embedded expressions now):<\/p>\n

 <\/p>\n

        <\/span>Dim<\/span> images =<\/span><\/p>\n

            <\/span><<\/span>html<\/span>><\/span><\/p>\n

                <\/span><<\/span>body<\/span>><\/span><\/p>\n

                    <\/span><%=<\/span><\/p>\n

                        <\/span>Iterator<\/span> <\/span>Function<\/span>()<\/span><\/p>\n

 <\/span><\/p>\n

                            <\/span>For<\/span> <\/span>Each<\/span> fn <\/span>In<\/span> IO.<\/span>Directory<\/span>.EnumerateFiles(<\/span>“c:\\”<\/span>, <\/span>“*.jpg”<\/span>)<\/span><\/p>\n

                                <\/span>Yield<\/span> <\/span><<\/span>img<\/span> <\/span>src<\/span>=<\/span><%=<\/span> fn <\/span>%><\/span>><\/<\/span>img<\/span>><\/span><\/p>\n

                            <\/span>Next<\/span><\/p>\n

                        <\/span>End<\/span> <\/span>Function<\/span>.Invoke() <\/span>%><\/span><\/p>\n

                <\/span><\/<\/span>body<\/span>><\/span><\/p>\n

            <\/span><\/<\/span>html<\/span>><\/span><\/p>\n

 <\/b><\/p>\n

Namespace Global
<\/b>VB has always had the Namespace<\/i> and Global<\/i> keywords, but now you can use them together!<\/p>\n

 <\/span><\/p>\n

Namespace<\/span> Global<\/span> <\/span><\/p>\n

Namespace<\/span> Global<\/span>.<NamespaceName><\/span><\/p>\n

 <\/p>\n

This gives you a lot more flexibility around which namespace your code ends up in, and is particularly useful for code-generation scenarios.  For a full description of the feature, check out Lucian’s excellent post here<\/a>. <\/p>\n

Optional Parameters in Overloaded Methods
<\/b>Previously, overloads of a method were not permitted if the only difference between them was optional parameters, so the following code would be invalid:<\/p>\n

    Sub<\/span> f(x As<\/span> Integer<\/span>)<\/span><\/p>\n

    End<\/span> Sub<\/span><\/span><\/p>\n

 <\/span><\/p>\n

    Sub<\/span> f(x As<\/span> Integer<\/span>, Optional<\/span> y As<\/span> Integer<\/span> = 0)<\/span><\/p>\n

    End<\/span> Sub<\/span><\/span><\/p>\n

 <\/p>\n

In VB11 this code is now valid, which gives you more flexibility and improves the ability to version methods (though there’s still more we need to do in this area).<\/p>\n

 <\/p>\n

Limitless (Command-line) Errors!
<\/b>This is actually a good thing, let me explain.  For performance reasons, the Visual Basic IDE maxes out at 101 errors (with error #102 being “Maximum number of errors exceeded.”)  This can make it difficult to estimate the amount of work remaining in certain situations, particularly in upgrade scenarios.  We have removed<\/i> this limit from the command-line compiler in this release, though it still there in the IDE.  What this means is if you want to know exactly how many errors there are for a project, just invoke the compiler through msbuild.exe or vbc.exe and you’ll get your answer.<\/p>\n

Caller Info Attributes
<\/b>The compiler now recognizes three special attributes: <CallerMemberName>, <CallerLineNumber>, and <CallerFilePath>.  This is great for logging scenarios, and allows you to have the name, line number, and\/or file path of the invoking method passed into the logging function as optional parameters. <\/p>\n

Another great use case for this is when implementing INotifyPropertyChanging:<\/p>\n

 <\/p>\n

    <\/span>Class<\/span> <\/span>C<\/span><\/p>\n

        <\/span>Implements<\/span> <\/span>INotifyPropertyChanged<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Dim<\/span> backing <\/span>As<\/span> <\/span>New<\/span> <\/span>Dictionary<\/span>(<\/span>Of<\/span> <\/span>String<\/span>, <\/span>Object<\/span>)<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Property<\/span> p <\/span>As<\/span> <\/span>String<\/span><\/p>\n

            <\/span>Get<\/span><\/p>\n

                <\/span>Return<\/span> GetProp(<\/span>Of<\/span> <\/span>String<\/span>)()<\/span><\/p>\n

            <\/span>End<\/span> <\/span>Get<\/span><\/p>\n

            <\/span>Set<\/span>(<\/span>ByVal<\/span> value <\/span>As<\/span> <\/span>String<\/span>)<\/span><\/p>\n

                SetProp(value)<\/span><\/p>\n

            <\/span>End<\/span> <\/span>Set<\/span><\/p>\n

        <\/span>End<\/span> <\/span>Property<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Public<\/span> <\/span>Function<\/span> GetProp(<\/span>Of<\/span> <\/span>T<\/span>)(<\/span><<\/span>CallerMemberName<\/span>()><\/span> <\/span>Optional<\/span> prop <\/span>As<\/span> <\/span>String<\/span> = <\/span>Nothing<\/span>) <\/span>As<\/span> <\/span>T<\/span><\/p>\n

            <\/span>Debug<\/span>.Assert(prop <\/span>IsNot<\/span> <\/span>Nothing<\/span>)<\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>Try<\/span><\/p>\n

                <\/span>Return<\/span> <\/span>CType<\/span>(backing(prop), <\/span>T<\/span>)<\/span><\/p>\n

            <\/span>Catch<\/span> ex <\/span>As<\/span> <\/span>KeyNotFoundException<\/span><\/p>\n

                <\/span>Return<\/span> <\/span>CType<\/span>(<\/span>Nothing<\/span>, <\/span>T<\/span>)<\/span><\/p>\n

            <\/span>End<\/span> <\/span>Try<\/span><\/p>\n

        <\/span>End<\/span> <\/span>Function<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Public<\/span> <\/span>Sub<\/span> SetProp(<\/span>Of<\/span> <\/span>T<\/span> <\/span>As<\/span> <\/span>IComparable<\/span>(<\/span>Of<\/span> <\/span>T<\/span>))(value <\/span>As<\/span> <\/span>T<\/span>, <\/span><\/p>\n

           <\/span><<\/span>CallerMemberName<\/span>()><\/span> <\/span>Optional<\/span> prop <\/span>As<\/span> <\/span>String<\/span> = <\/span>Nothing<\/span>)<\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>Try<\/span><\/p>\n

                <\/span>Dim<\/span> oldvalue = <\/span>CType<\/span>(backing(prop), <\/span>T<\/span>)<\/span><\/p>\n

                <\/span>If<\/span> value.CompareTo(oldvalue) = 0 <\/span>Then<\/span> <\/span>Return<\/span><\/p>\n

            <\/span>Catch<\/span> ex <\/span>As<\/span> <\/span>KeyNotFoundException<\/span><\/p>\n

            <\/span>End<\/span> <\/span>Try<\/span><\/p>\n

 <\/span><\/p>\n

            backing(prop) = value<\/span><\/p>\n

            <\/span>RaiseEvent<\/span> PropertyChanged(<\/span>Me<\/span>, <\/span>New<\/span> <\/span>PropertyChangedEventArgs<\/span>(prop))<\/span><\/p>\n

        <\/span>End<\/span> <\/span>Sub<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Public<\/span> <\/span>Event<\/span> PropertyChanged(sender <\/span>As<\/span> <\/span>Object<\/span>, e <\/span>As<\/span> <\/span>PropertyChangedEventArgs<\/span>) <\/span>Implements<\/span> <\/span>INotifyPropertyChanged<\/span>.PropertyChanged<\/span><\/p>\n

 <\/span><\/p>\n

    <\/span>End<\/span> <\/span>Class<\/span><\/p>\n

  <\/p>\n

Simplified Code Spit (a.k.a. No More ByVal!)
<\/b>The IDE will no longer insert “ByVal” in method signatures unless you explicitly type it in.  This reduces a lot of the visual noise in method declarations and makes them more readable.  Also, the IDE will no longer insert the fully-qualified name for a type (such as “System.Object” or “System.EventArgs”) when the applicable imports are already in scope.  (Because in this case “System” is already a project-level import).<\/p>\n

VB10:<\/p>\n

Private<\/span> Sub<\/span> Form1_Load(ByVal<\/span> sender As<\/span> System.Object<\/span>, ByVal<\/span> e As<\/span> System.EventArgs<\/span>) Handles<\/span> MyBase<\/span>.Load<\/span><\/p>\n

 <\/p>\n

VB11:<\/p>\n

Private<\/span> <\/span>Sub<\/span> Form1_Load(sender <\/span>As<\/span> <\/span>Object<\/span>, e <\/span>As<\/span> <\/span>EventArgs<\/span>) <\/span>Handles<\/span> <\/span>MyBase<\/span>.Load<\/span><\/p>\n

 <\/p>\n

This also works automatically for all interface methods generated when you press enter after an Implements clause.<\/p>\n

 <\/p>\n

View Call Hierarchy
<\/b>In VB11, if you right-click a method name, you’ll see a new option for “View Call Hierarchy” that brings up a window that looks like this: <\/p>\n

\"\"<\/a> 
(Click on the image to see a more detailed view)<\/div>\n
 <\/div>\n

It shows you all calls to\/from that method, and also if it gets overridden anywhere.  You can then walk the tree and understand how these methods are used throughout your codebase.  For a more detailed overview, check out this post<\/a>.<\/p>\n

 <\/p>\n

Getting Started
<\/b>Hopefully that gives you a taste of what’s new in VB11 (and we haven’t even touched on all the performance improvements!).  There are far more enhancements than we can cover here, so watch for a future post that goes into more detail.  For next steps:<\/p>\n

 <\/p>\n

1.       <\/span><\/b>Download the Bits!
<\/b>Download Visual Studio 11 Beta<\/a> (you can also get Team Foundation Server 11 Beta, and .NET Framework 4.5 Beta from here).  Visual Studio 11 Beta can be installed on Windows 7, or you can install it on top of the Windows 8 Consumer Preview<\/a>.<\/p>\n

 <\/p>\n

2.       <\/span><\/b>Learn More!
<\/b>In addition to Jason’s post, Jason’s announcement<\/a>, be sure to check out the new Windows 8 app developer blog<\/a> for a list of great improvements across Visual Studio.  For Samples, check out the Windows 8 Sample Gallery<\/a>. To explore what’s new in Windows 8, check out the Building Windows 8 blog post announcing the Windows 8 Customer Preview<\/a>.<\/p>\n

 <\/p>\n

3.       <\/span>Send us Feedback<\/b>!
The forums are available for questions, both in Visual Studio<\/a> and Windows 8<\/a>.  If you find a bug please let us know through the Microsoft Connect site<\/a>. For feature suggestions check out the UserVoice<\/a> site (which also allows you to vote on other users’ feature ideas). <\/p>\n

 <\/p>\n

We hope you enjoy the product and look forward to seeing tons of great VB apps!<\/p>\n

Jon Aneja, Program Manager, VB\/C# Compiler Team
Lucian Wischik, Program Manager, VB Spec Lead<\/p>\n","protected":false},"excerpt":{"rendered":"

As you may have read in Jason’s announcement, today we announced that Visual Studio 11 Beta is now available for download.  This is a huge release for Visual Basic as it provides full platform support for building Windows 8 Metro style apps, a first-class asynchronous programming experience, and also the long-awaited Iterators feature.  And in […]<\/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":[195],"tags":[36,37,39,74,83,99,162,171,174],"class_list":["post-353","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-visual-basic","tag-async","tag-asynchronous-programming","tag-await","tag-ide","tag-jonathan-aneja","tag-lucian-wischik","tag-vb","tag-visual-basic","tag-visual-studio"],"acf":[],"blog_post_summary":"

As you may have read in Jason’s announcement, today we announced that Visual Studio 11 Beta is now available for download.  This is a huge release for Visual Basic as it provides full platform support for building Windows 8 Metro style apps, a first-class asynchronous programming experience, and also the long-awaited Iterators feature.  And in […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/353","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=353"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/353\/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=353"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=353"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=353"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}