The Visual Basic Team

Roslyn September 2012 CTP Available for Download!

VBTeam — Mon, 17 Sep 2012 18:29:00 GMT

VB Enthusiasts,

Following last Wednesday’s official launch of Visual Studio 2012, we’re excited to announce that the Roslyn September 2012 CTP is now available for download and provides support for VS 2012 RTM. Please note that Visual Studio 2010 is no longer supported by this CTP.

We’ve been hard at work since the first public release of Roslyn adding support for new language features and improving our APIs. In addition, we’ve also updated our NuGet packages to match the September 2012 CTP.

As always, your feedback is critical! Please get involved in the discussion on the Roslyn forum, file bugs on Connect, or just give us a shout-out on Twitter @ #RoslynCTP!

Regards,

-ADG

Install Published Samples with Visual Studio

Alan Berman — Wed, 27 Jun 2012 15:00:00 GMT

You can use Visual Studio 2012 RC to download and install samples from the MSDN Code Gallery. You can download only the samples you need, or you can download one or more Sample Packs, which group several samples that relate to a technology or topic. You'll receive a notification if source code changes are published for any sample that you download.

To locate the samples, open the New Project dialog, and then expand the Online tab, and then the Samples node.

To locate the sample packs, choose Tools, Extensions and Updates on the menu bar. In the Extensions and Updates dialog box, expand the Online tab, and then expand the Samples Gallery node. After you install a sample pack, you can install the individual samples from the Installed tab of the New Project dialog box.

Working Copy and Master Copy

When you install an online sample, the solution is stored in two locations:

• A working copy is stored in the location that you specify by using the New Project dialog box.
• A separate master copy is stored on your computer.

After you install a sample, it appears on the Installed tab of the New Project dialog box. You can create new working copies from the master copy without remembering where you found the sample on the web and without being connected to the Internet.

If a sample is no longer useful, you can remove the master copy from the Extensions and Updates dialog box, which you can open by choosing Tools, Extensions and Updates. Removing the master copy doesn't remove any working copies that you created.

You'll receive a notification if source code changes are published for an installed master copy of a sample. The notification will appear in both the Windows notification area when Visual Studio is open and on the Updates tab of the Extensions and Updates dialog box. If you update a sample, you'll replace the master copy but not any working copies.

Installing a Sample

To install a sample, choose File, New, Project. In the New Project dialog box, expand the Online tab, and then expand the Samples node.
Find the samples that you want by opening the nodes for the programming language, the platform, and the technology and then choosing the topic. Or you can use the Search Installed Samples box in the top-right corner. Choose a sample that you want to install.
For the Name, specify a name for the first working copy of the sample. When you install the sample, the Name will become the name of the folder and the name of the solution file. Names of other files in the working copy will stay the same as those in the master copy. The Name doesn’t apply to the master copy.
For the Location, specify a folder. The location is where the working copy, not the master copy, will be installed. Note that the default value is a Samples folder and not a Projects folder.
Click OK. If you agree with the license terms, click Install. A working copy of the solution is stored in the location that you specified, and a separate master copy is stored on your computer.

You can open a working copy of an installed sample by using the Open Project dialog box. Note that the default location for the working copy was the Samples folder, not the Projects folder.

Managing the Master Copy of an Installed Sample

You can create a working copy of an installed sample from its master copy, or you can disable or uninstall the master copy. Let's look at two dialog boxes where you can access the master copy.
Open the New Project dialog box, then expand the Installed tab, and expand the Samples node. Expand the nodes for the programming language, the platform, and the technology, and then choose the topic.
The master copies of the samples that you've installed appear. Double-click a sample to create a new working copy. On the Installed tab, you can create working copies from the master copy without remembering where you found the sample on the web or being connected to the Internet.
Close New Project dialog box and open Tools, Extensions and Updates.
In the Extensions and Updates dialog, choose the Installed tab, and then expand the Samples node. The master copies of the samples that you've installed appear. You can disable or uninstall master copies without affecting any working copies that you've created.
Note that if source code changes have been published for any sample that you installed, a notification appears on the Update tab. For each update listed, you can choose the Update button to update your master copy.

Installing a Sample Pack

Choose Tools, Extensions and Updates. In the Extensions and Updates dialog box, expand the Online tab, and then expand the Samples Gallery node.
Find the sample pack that you want by using the Search Samples Gallery box in the top-right corner or by expanding the nodes for the programming language, the platform, and the technology and then choosing the topic.
Choose a sample pack, and click Download. If you agree with the license terms, click Install. The sample pack is installed on your computer, but working copies of the samples haven't been created.
Close Extensions and Updates and choose File, New, Project. In the New Project dialog, expand the Installed tab, and then expand the Samples node. Browse the nodes or use the Search Installed Samples box in the top–right corner to find the samples that you installed. Double-click the sample to create a new working copy of that sample.

For more information, see A World of Samples at your Fingertips.

Thanks to Anthony Cangialosi for providing technical information.

More VB Metro Samples available

VBTeam — Tue, 05 Jun 2012 23:27:26 GMT

With the recent release of the Windows 8 Release Preview and the Visual Studio 2012 Release Candidate we also have more of the Metro samples available for VB developers.

Although not all the samples are available for VB, there is a good selection of samples showing you how utilize much of the important functionality now available. More samples will be made available as the all the products move towards their final RTM relase.

Spotty

Resources

Windows 8 Release Preview - http://windows.microsoft.com/en-US/windows-8/release-preview

Visual Studio 2012 RC - http://www.microsoft.com/visualstudio/11/en-us

Metro Style Apps - http://code.msdn.microsoft.com/windowsapps/Windows-8-Modern-Style-App-Samples

Announcing Microsoft “Roslyn” June 2012 CTP

VBTeam — Tue, 05 Jun 2012 20:00:00 GMT

Hey, fellow VBs,

Today, we're excited to announce that the Roslyn June 2012 CTP is now available for download!

Since the first public release of Roslyn, we’ve been hard at work implementing new language features, addressing top customer feedback from the October CTP, iterating on our API design and improving performance across our IDE and compiler scenarios. With the recent release of Visual Studio 2012 RC, we have updated the Roslyn CTP to work with Visual Studio 2012 RC. There’s never been a better time to grab the VS 2012 RC and the Roslyn CTP!

You can find an in-depth look at what’s new in the Roslyn June 2012 CTP on Jason Zander’s blog and the Visual Studio blog. The CTP ships with a number of documents that provide an excellent way to get started – start with the overview document, and then move on to the walkthroughs. The syntax visualizer is particularly an invaluable tool for exploring the Roslyn Syntax API. Also, stay tuned for more posts on this blog using the API to do cool things with VB!

As always, your feedback is a critical part of our design process! Because it’s early in the project, we’re most interested in feedback around the API and understanding what scenarios you’d like to accomplish. Please get involved in the discussion about Roslyn on our forums. You can also file bugs on our Connect site. Some of the team members are also on Twitter, and will be keeping an eye on the #RoslynCTP hashtag.

Regards,

-ADG

About the Author

Anthony is a Program Manager on the Visual Basic and C# Languages team primarily responsible for the Roslyn compilers and Compiler APIs and is a member of both the Visual Basic Language Design team and the Roslyn Design team.

Kinect SDK v1.5 - Now with VB Samples !!!

VBTeam — Fri, 25 May 2012 17:25:35 GMT

As developers start to realize the full potential of Microsoft Kinect and new hardware is made available for the PC it’s really great to see the Kinect team provide some sample support for VB developers.

For a while the Compilers team (who handle both VB and C# compilers) have been hearing VB developers asking for content on new technologies and have been working with other product teams to ensure VB developers get some content in a timely manner.

The Kinect team has included a “Basics” series of samples with language coverage in C++, C# and Visual Basic. Kudos to the Kinect team for realizing that VB developers also want to use their cool technology. Although not every sample has a VB equivalent, there is definitely enough content to get VB developers and running with this amazing technology and the great potential this opens up for interacting with you applications.

The new version of the SDK is able to be used with existing Kinect for Xbox360 hardware for you own personal development purposes and this should get you going if you happen to have one lying around, however the newer more advanced Windows Sensor is definitely recommended and should be planned for if you want to do anything for public release.

Kinect Team Page

http://www.microsoft.com/en-us/kinectforwindows/

SDK Download

http://www.microsoft.com/en-us/kinectforwindows/develop/developer-downloads.aspx

Spotty

Async Targeting Pack for Visual Studio 11, now available for .NET 4 and Silverlight 5

VBTeam — Thu, 26 Apr 2012 16:01:00 GMT

If you’ve held off trying Visual Studio 11 Beta because your .NET 4 or Silverlight 5 app uses the Async CTP, your wait is over!

Today we’ve published the Async Targeting Pack for Visual Studio 11, a NuGet package that lets your Visual Studio 11 projects target .NET 4 and Silverlight 5 while taking advantage of VB11's new Await keyword. While Visual Studio 11 provides built-in support for Await in projects that target .NET 4.5 or .NET for Metro style apps, this targeting pack provides the API support to expand the set of target platforms to include .NET 4 and Silverlight 5 as well.

Check out our release notes for more details on how to install NuGet and add the package reference in Visual Studio 11 Beta, and read Lucian Wischik's blog post for more details.

Happy async!

Visual Basic 11 Beta Available for Download!

VBTeam — Wed, 29 Feb 2012 02:18:00 GMT

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 the true spirit of VB, you’ll see a ton of other improvements that will make you more productive every day.

Async
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:

Public Async Function GetStorageFile() As Task(Of Windows.Storage.StorageFile)

Dim packageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation

TextBlock1.Text = "Retrieving File..."

Dim packagedFile = Await packageFolder.GetFileAsync("FileLocatedInPackage")

...

Return packagedFile

End Function

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 and the variable packagedFile is assigned to.

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

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.

The other thing we’ve added is async unit-testing support in MSTest. xUnit now supports this as well.

Async Function Test1() As Task

Dim x = Await Engine.GetSevenAsync()

Assert.AreEqual(x, 6)

End Function

<Xunit.Fact>

Async Function Test2() As Task

Dim x = Await Engine.GetSevenAsync()

Xunit.Assert.Equal(x, 6)

End Function

Iterators
Iterators 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.

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:

Module Module1

Sub Main()

Dim query = From n In {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Where n Mod 2 = 0

Select n

For Each item In query

Console.WriteLine(item)

Console.ReadLine()

End Sub

<System.Runtime.CompilerServices.Extension>

Iterator Function Where(source As Integer(),

predicate As Func(Of Integer, Boolean)

) As IEnumerable(Of Integer)

For Each num In source

If predicate(num) Then

Console.WriteLine("Yielding " & num)

Yield num

End If

End Function

End Module

Note the new Iterator and Yield 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).

VB also allows iterator lambdas! 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 inside embedded expressions now):

Dim images =

<html>

<body>

<%=

Iterator Function()

For Each fn In IO.Directory.EnumerateFiles("c:\\", "*.jpg")

Yield <img src=<%= fn %>></img>

End Function.Invoke() %>

</body>

</html>

Namespace Global
VB has always had the Namespace and Global keywords, but now you can use them together!

Namespace Global

Namespace Global.<NamespaceName>

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.

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

Sub f(x As Integer)

End Sub

Sub f(x As Integer, Optional y As Integer = 0)

End Sub

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).

Limitless (Command-line) Errors!
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 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.

Caller Info Attributes
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.

Another great use case for this is when implementing INotifyPropertyChanging:

Class C

Implements INotifyPropertyChanged

Dim backing As New Dictionary(Of String, Object)

Property p As String

Get

Return GetProp(Of String)()

End Get

Set(ByVal value As String)

SetProp(value)

End Set

End Property

Public Function GetProp(Of T)(<CallerMemberName()> Optional prop As String = Nothing) As T

Debug.Assert(prop IsNot Nothing)

Try

Return CType(backing(prop), T)

Catch ex As KeyNotFoundException

Return CType(Nothing, T)

End Try

End Function

Public Sub SetProp(Of T As IComparable(Of T))(value As T,

<CallerMemberName()> Optional prop As String = Nothing)

Try

Dim oldvalue = CType(backing(prop), T)

If value.CompareTo(oldvalue) = 0 Then Return

Catch ex As KeyNotFoundException

End Try

backing(prop) = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(prop))

End Sub

Public Event PropertyChanged(sender As Object, e As PropertyChangedEventArgs) Implements INotifyPropertyChanged.PropertyChanged

End Class

Simplified Code Spit (a.k.a. No More ByVal!)
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).

VB10:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

VB11:

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

This also works automatically for all interface methods generated when you press enter after an Implements clause.

View Call Hierarchy
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:

(Click on the image to see a more detailed view)

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.

Getting Started
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:

1. Download the Bits!
Download Visual Studio 11 Beta (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.

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

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

We hope you enjoy the product and look forward to seeing tons of great VB apps!

Jon Aneja, Program Manager, VB/C# Compiler Team
Lucian Wischik, Program Manager, VB Spec Lead

New VB XNA Sample - showing Xbox, Windows and Phone targetting

VBTeam — Mon, 12 Dec 2011 21:58:07 GMT

For all those who have started venturing into developing windows phone applications, there are quite a few samples utilizing Silverlight, but the XNA content has been a little bit light. (We are working on getting some more XNA VB samples online).

But for those wanting to see a nice VB example of XNA development, the Blackjack sample written in VB is now online. This sample shows a single application which has been written to target all three of the XNA platforms (windows, XBox 360 and windows Phone) with a simple game that is easy to follow the code.

http://create.msdn.com/en-US/education/catalog/sample/blackjack

Enjoy

Spotty

VB Support for Microsoft Surface 2.0

VBTeam — Tue, 22 Nov 2011 01:26:07 GMT

Touch screen are great and we’ve seen their use on phone and slates but sometimes these screens still just are not big enough. For those who desire bigger touch screens, Microsoft surface may be the answer. Microsoft surface has been around a while and there have been significant changes with version 2.0. Version 2.0 introduces new functionality and support for more compact hardware. A glance at the Microsoft Surface team web site reveals some incredibly interesting uses for the technology.

The samples provided are a great introduction to writing code for the platform. VB versions of all the samples have been created and they provide a introduction to what is possible.

To develop Surface applications using VB requires installation of a few prerequisites:

VS2010 SP1 (Required because VB is using VB Core feature)
WP7 SDK Tools (Installs the XNA components )
Surface 2.0 Runtime and SDK (The important surface tools)
VB Surface 2.0 Samples

And for those who feel inspired to create new surface projects from scratch we have included the project templates. To install these project templates after installing the above prerequisites – you can find then in the Visual Studio Gallery (Tools > Extension Manager) searching on the “VB_Surface” and install the new project templates.

You can now start up Visual Studio and the two surface templates should appear for Visual Basic as well as the existing two C# surface templates. This is another technology that is now targetable by VB developers and that utilizes the VB Core functionality.

Enjoy….

Spotty

Roslyn Syntax Visualizers

VBTeam — Sat, 19 Nov 2011 02:00:00 GMT

Hi All! A few weeks ago, we announced the Microsoft "Roslyn" CTP. I hope many of you have had a chance to download the CTP and take it for a spin :) If you haven’t, do give it a try.

To recap – in the Roslyn CTP, we are previewing a powerful set of language services APIs that you can use within your apps to reason about VB and C# code. We are also previewing IDE extensibility points for VB and C# that will allow you to build rich code refactorings, quick fixes etc. that run inside Visual Studio.

In this post, I just wanted to point out a couple of tools that you may be interested in if you are working with the CTP – the Roslyn Syntax Visualizers. You can read more about these visualizers and how to install and use them on the following blog post – http://blogs.msdn.com/b/visualstudio/archive/2011/10/19/roslyn-syntax-visualizers.aspx

The visualizers ship as samples in the CTP and allow you to visually inspect and explore Roslyn Syntax Trees (below screenshot shows an example). You can use these visualizers as debugging aids when you develop your own applications / code refactorings using the Roslyn APIs.

Happy Coding! :)

Shyam Namboodiripad
Software Development Engineer in Test (Roslyn Compilers Team)

Putting back functionality left out of VB Core - ( If you can't live without Mid when writing WP7 apps ;-) )

VBTeam — Thu, 10 Nov 2011 05:12:00 GMT

For development of windows phone applications a new feature was added to the Visual Basic compiler known as VB Core. This is a reduced version of the runtime designed to allow development for a broader variety of platforms without incurring the larger penalty of having a full VB runtime containing non-supported or older VB6 legacy functionality which are now implemented as part of the framework itself. However this results in some features not being supported on this platform such as Late binding, My functionality and some
legacy VB functions. You may not be targeting WP7 yet but this reduced runtime is also being incorporated into other target platforms such as Portable Class Libraries.

For many developers who have been using only VB.Net this may not be an issue as they would be familiar with the .NET framework functionality which is typically what is shown in samples and example code that is translated from C#. WP7 is a new platform and much of the code written for this platform is new as well. However, if you have some legacy code that you want to use on this platform and that code uses some of functionality not supported by VB Core, it is possible to create your own implementations to reinstate this functionality

(DISCLAIMER:
This would be your own implementation of this functionality and you assume all risk and responsibility for maintaining it and any consequent increase in assembly size. Microsoft assumes no responsibility for the quality or accuracy of your implementation. Use this technique at your own risk).

Remember, some of this functionality was left out because it may not be applicable to the platform. An example of this is the My.Computer.FileSystem functionality because the platform utilizes a different form of storage known as Isolated Storage. But there is no reason you couldn’t create your own implementation of My helper functions.

We have created a simple example showing how to reinstate some of the functionality which is not included in VB Core. Examples include Left, Right and Mid functionality.

How do you find the code to create your own implementations of these functions?
The source for the VB Runtime is and other assemblies are publically available, so you can see how these functions are implemented.

http://blogs.msdn.com/b/rscc/archive/2010/08/16/net-framework-4-reference-source-is-available.aspx

You can then choose to either include this code directly in your application or create a simple class library which you can then reference from your projects to ensure that you can use the specific functions you require that are not included in VB Core. You may want to clean up the implementation a little as there is some throwback code related to VB6 which may no longer be applicable.

The project is designed to show you have to add back missing functionality – if you really can’t life without functions such as Left, Mid, Right. The sample is designed to show you how you can put back small bits for VB runtime functionality left out of VB if you absolutely need to, but the recommended course of action would be to use existing framework functionality when targeting these new platforms using the VBCore functionality.

Spotty

Halloween: VB Style!

VBTeam — Mon, 31 Oct 2011 14:27:00 GMT

Imagine this. It’s Halloween. You’ve got a costume party to go to at 7 but there’s one small hiccup – you’ve got no costume. As a VB programmer you’re used to coming up with nick-of-time solutions to all manner of complex business problems but all your coding skills won’t help you now. After all, you can’t just code up a costume – or can you? Here’s a little number I cooked up two years ago (before I joined the Developer Ghouls division at Microsoft) called the Opensourus Hex costume.

First, make up a short but interesting VB program and write it out (in carefully color-coded marker) on a white t-shirt like so:

Don’t forget to include your license:

Get yourself a box and throw in some art supplies – string, tape, construction paper, beer cans, whatever – label it “SDK” or “Developer Tools”.

Print off some reference materials:

And then let all of your friends at the party go nuts interactively creating you a costume (while asking you to explain all the 1337 VBisms written on your chest. It may sound silly but trust me it’s fun (for you AND your fellow party-goers). I actually did this with an old friend of mine two years back and he kept the project going for two years in a row. Take a look at some of the things his friends came up with:

Opensourus Hex v1.0

Friend (Eric) wearing costume next to then dev lead (Me)

Opensourus several iterations later:

Opensourus v2.0

That's the best thing about the Opensourus costume - every year it's different.

In my next post I’ll show you how to use VB lambda expressions as a last minute substitute to an undercooked Thanksgiving turkey (or will I?).

Happy Halloween and Happy Coding!

Anthony D. Green
Program Manager
Visual Basic & C# Languages Team

Introducing the Microsoft "Roslyn" CTP

VBTeam — Wed, 19 Oct 2011 21:00:00 GMT

(Begin dramatic movie trailer music, slow PowerPoint slide show with cliché sound effects)

October 2006 –VB Architect-emeritus Paul Vick responds via his blog to question by some completely random VB customer named Anthony about bootstrapping the VB compiler (rewriting it in VB), admits no definite plans yet but says that “one thing that would be nice about a managed compiler would be opening up the services to other tools...”
April-May 2007 – Paul Vick begins to open up on his blog about forward looking internal plans to make a hostable/scriptable future version of Visual Basic using a managed component written in VB.
2008-2009 – Other stuff happens
October 2010 – At PDC 10 Technical Fellow Anders Hejlsberg gives update on “Roslyn” project (formerly known as compiler-as-a-service)
May 2011 – In a VB Team blog post celebrating Visual Basic’s 20^th year at Microsoft PM Anthony D. Green writes of great anticipation about VB’s future, including a complete compiler rewrite and a new set of managed APIs built on top of the new compiler
September 2011 – At BUILD Technical Fellow Anders Hejlsberg demos C# Interactive and Scripting built using the Roslyn APIs, anticipates eminent release of preview bits.
October 2011 – Microsoft releases the Roslyn CTP – <--YOU ARE HERE

OK, maybe I have a flair for the dramatic but that’s because today is such a dramatically exciting day. After years of foreshadowing, and mentioning, and updating on our part I’m thrilled to announce on behalf of the united Visual Basic & C# Languages Team the availability of the Microsoft “Roslyn” CTP. This early preview represents an incredible milestone for us in a years-long process of bootstrapping both languages and providing a rich set of APIs exposing a host of compiler analyses and services.

And, there’s more goodness to the Roslyn project than just what you can do with the new compilers alone. We’re also previewing a powerful set of Language Services APIs and extensibility points to allow 3^rd parties to do amazing things inside Visual Studio using the compiler APIs like creating custom code issues and quick-fixes and even writing custom refactorings.

But wait, there’s more. If you download the CTP today we’ll throw in a preview of what we’re thinking about for an Interactive (REPL) window experience in VB and C#. The VB Interactive window isn’t quite baked yet for this CTP so we’re holding that goodness in reserve for a future release. But in the meantime you should play with the C# Interactive window anyway and let us know what you like, what you don’t like, and what you think might be different from C# that is important to you for the unique VB Interactive experience.

Next steps:

Where you can learn more and get it: http://msdn.com/roslyn
What you should do with it: Make code-smart tools, play with the Interactive window
Where you should send your feedback: Roslyn Forums for discussions, Connect for bugs, #RoslynCTP for Twitter shout-outs.
What you should know before sending feedback: That this is a technology preview and that it has known limitations. The API generally looks the way we think it should look but not all of either language is implemented at this time (see the Forums for a list of known limitations and unimplemented language features).

The CTP includes a wealth of documents and samples to get you started using Roslyn, but keep a look out on this blog (and the Roslyn homepage) for more posts exploring the Roslyn APIs – including a series of posts starting this month by yours truly.

Happy Experimenting!

Anthony D. Green
Program Manager
Visual Basic & C# Languages Team

Announcement: Namespace Global

VBTeam — Tue, 27 Sep 2011 17:50:00 GMT

There’s a new feature coming to VB, and already included in the Visual Studio 11 Developer Preview. The feature is called Namespace Global and it’ll make your life easier…

if you part of your code belongs in a different namespace from the rest of your project,
if you use code-generating tools, which need to choose which namespace they write into.

The MSDN reference on namespaces (including Namespace Global) is here: Namespaces in Visual Basic.

As an aside, I’d like to thank Shimmy Wietzhandler for requesting this feature in Microsoft Connect, and also the people who emailed or who wrote in with comments to Lucian Wischik’s VB language-design blog. It’s from user feedback like these that we decide which features to prioritize. For the future, we’ve launched the Visual Studio UserVoice site to gather together these kinds of feature requests.

Release note: the Visual Studio 11 Developer Preview doesn’t yet have full IDE support for the Namespace Global feature (e.g. NavigateTo doesn’t work). This in the works.

Background

This feature is tied to the project’s Root Namespace, pictured above, which you find by double-clicking on “My Project” in the Solution Explorer. Every single class and namespace you write is implicitly placed inside that Root Namespace. Here’s an example class library I wrote:

    Public Class InsulinData
    End Class

    Public Class PatientID
    End Class

    Namespace Utils
       Public Class LinearRegressionSolver
       End Class
    End Namespace

The fully-qualified names of my classes are like these (note that you never actually need to write the prefix “Global” – I put it in here for completeness):

    Dim x As New Global.MedicalDeviceAnalysis.InsulinData
    Dim y As New Global.MedicalDeviceAnalysis.PatientID
    Dim z As New Global.MedicalDeviceAnalysis.Utils.LinearRegressionSolver

Most of the time, this is exactly what you want.

Problem

But in this particular case, I didn’t want “Utils.LinearRegressionSolver” to come under MedicalDeviceAnalysis – because it’s a general-purpose utility, and not specific to medical device analysis at all.

Fixing my code in VS2010 is awkward. I have to set MyProject > RootNamespace to nothing, and then go through my entire project manually putting every single class inside “Namespace MedicalDeviceAnalysis”.

Namespace Global

We have introduced a new way to “escape” your classes out of the project’s Root Namespace. It works like this:

    Namespace Global.Utils
        Public Class LinearRegressionSolver
        End Class
    End Namespace

By writing “Namespace Global” explicitly, I get the classes where I want – regardless of the project’s Root Namespace:

    Dim x As New Global.MedicalDeviceAnalysis.InsulinData
    Dim y As New Global.MedicalDeviceAnalysis.PatientID
    Dim z As New Global.Utils.LinearRegressionSolver

Namespace Global: extension-method scenario

Here’s another scenario where Namespace Global will help. Let’s say that my MedicalDevice library has become quite large, composed of several class libraries and namespaces – for instance, one of the class libraries will have Root Namespace set to “MedicalDevice.Analysis”.

But I also established the convention that users merely need to “Imports MedicalDevice” to get all the extension methods. Here’s how:

Namespace Global.MedicalDevice
    Public Module Extensions
        <Extension>
        Public Function AsPatientID(this As String) As MedicalDeviceAnalysis.PatientID
            Return New MedicalDeviceAnalysis.PatientID(this)
        End Function
    End Module
End Namespace

We actually used this technique in the recent Async CTP. We wanted our extensions to be defined in the global namespace so that people could use them without having to import anything. (This design is generally frowned upon, but it made sense in this case). Again, we used the Namespace Global feature:

Namespace Global
    Public Module AsyncCtpExtensions
        <Extension>
        Public Function DownloadStringTaskAsync(this As WebClient) As Task(Of String)
            ' ...
        End Function
    End Module
End Namespace

Namespace Global: codegen scenario

One important behind-the-scenes use of Namespace Global is for code-generation tools. Let’s say (for instance) that you wrote a T4 template which automatically spits out code, but it needs the code to go inside a particular namespace. The T4 template can’t make any assumptions about Root Namespace.

Now, using Namespace Global, the T4 template can chose precisely which namespace to use for its generated code.

Namespace Global: under the hood of VB-Core

We in the VB team used Namespace Global for a powerful new feature that came in VS2010 SP1 called “VB-Core”. The point of VB-Core is to embed a small part of Microsoft.VisualBasic.dll inside your own assembly, so you can produce a stand-alone executable that works even on platforms which lack the DLL such as the Micro Framework.

The VB compiler actually embeds that small part of Microsoft.VisualBasic as a “ghost” .vb source file which it implicitly adds to your project. The classes defined in that file must go inside the namespace Global.Microsoft.VisualBasic: they cannot be nested inside the project’s Root Namespace. I’m sure you can guess how the ghost file starts…

"Namespace Global.Microsoft.VisualBasic" & vbCrLf &
" Namespace CompilerServices" & vbCrLf &
"    Friend Class Operators" & vbCrLf &
"      Public Shared Function CompareString(Left As String, Right As String, TextCompare As Boolean) As Integer" & vbCrLf &
"        If Left Is Right Then Return 0" & vbCrLf &

Namespace Global: specification

In addition to the existing VS2010 namespace declarations, VB will allow two new forms of namespace declaration:

Namespace Global
Namespace Global.<NamespaceName>

These are both only allowed at top level in a source file (i.e. not nested inside any other Namespace declaration). The first form declares that its contents will go inside the global namespace. The second form declares a namespace within the global namespace, and puts its contents there.

Full details are at MSDN: Namespaces in Visual Basic.

Visual Studio 11 Developer Preview: Visual Basic (VB) Call Hierarchy

VBTeam — Tue, 20 Sep 2011 18:00:00 GMT

By Zain Naboulsi (Blog)

Default: CTRL + ALT + K

Menu: View | Call Hierarchy

Command: View.CallHierarchy; EditorContextMenus.CodeWindow.ViewCallHierarchy

Versions: Visual Studio 11 Developer Preview

Languages: VB

With the announcement of the Visual Studio 11 Developer Preview it’s time to take a look at some of the features you can start using with our latest version of the IDE right away. If you are already familiar with the C++/C# Call Hierarchy feature from my previous blog post then you are already familiar with the features and may just want to start playing with this on your own. For those not familiar, I’ll repeat the content here. And now on with the tip…

(queue choir music)

Visual Basic developers everywhere rejoice!

The Call Hierarchy is now available for VB!

This feature allows you to visually inspect the calls to and from any selected method, property, or constructor. Simply right-click any method, property, or constructor name and select View Call Hierarchy:

This will bring up the Call Hierarchy window:

Note the Calls To and Calls From areas? You can expand them to see a list under each node if applicable:

If you select an item under one of these areas then you will get a list of Call Sites that show where the calls are happening:

You can double-click any call site to go to the line of calling code:

Instead of doing a double-click you can also right-click the call site and choose Go To Reference or you can copy the name and location of the call site as you see it listed:

You can also right-click any items in the tree-view to get a list of possible actions:

Here is a table of the actions you may come across and what they can do for you:

Context Menu Item	Description
Add As New Root	Adds the selected node to the tree view pane as a new root node.
Remove Root	Removes the selected root node from the tree view pane. This option is available only from a root node. You can also use the Remove Root toolbar button to remove the selected root node.
Go To Definition	Runs the Go To Definition command on the selected node. This navigates to the original definition for a method call or variable definition. You can also press F12 to run the Go To Definition command on the selected node.
Find All References	Runs the Find All References command on the selected node. This finds all the lines of code in your project that reference a class or member. You can also use SHIFT+F12 to run the Find All References command on the selected node.
Copy	Copies the contents of the selected node (but not its subnodes).
Refresh	Collapses the selected node so that re-expanding it displays current information.

So, just as with C++ and C#, we now have the Call Hierarchy feature available for VB developers. This is all part of our master plan to get all languages on parity with each other so that most features are available regardless of the language used. Enjoy!

Dynamics CRM 2011 Developer Training Kit - Updated with VB Source

VBTeam — Thu, 08 Sep 2011 19:26:50 GMT

An update to the training kit has been made providing Visual Basic developers with sample code for the development features of Dynamics CRM and help them build applications using Microsoft Dynamics CRM 2011 and CRM Online.

Download available at

http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=23416

Updated Samples for WP7 Developers

VBTeam — Sat, 27 Aug 2011 02:02:50 GMT

For those VB developers who are developing (or keen to start developing) for WIndows Phone 7. The samples have been updated and as you'll notice virtually all of them are in both C# and VB.

http://msdn.microsoft.com/en-us/library/ff431744(VS.92).aspx

New Async Programming Video's

VBTeam — Fri, 12 Aug 2011 20:17:00 GMT

Some great new video's on MSDN showing how to do async programming using the Async CTP.

http://msdn.microsoft.com/en-us/vstudio/hh378091.aspx

There are different versions of video's for both VB and C#. This is a great opportunity to see the power of the new Async languages featuresand follow through a series of examples showing how easy it is to use the new feature.

Also, the MSDN forums have one specifically dedicated to the Async CTP which compilers team member are monitoring to help answer any questions.

http://social.msdn.microsoft.com/Forums/en-US/async/threads

[Update] Code Samples attachment

Spotty

Temperature Monitoring using VB.Net, Micro-framework and a Netduino

VBTeam — Tue, 02 Aug 2011 21:31:00 GMT

Introduction

As a bit of a geek, I like to tinker with basic gadgets. I often think of little ideas that would be great to implement but the device involves some hardware and very little software. As a software engineer I tend to think in terms of simple programs to but in order to implement something tangible would involve electronics and the interface between embedded electronics and high level languages such as VB or C# is somewhat disconnected. For a long time much of the embedded devices was coded using low level languages such as assembler and the prospect of going back to write assembler or getting into more complex electronics is something that I just don’t have the time to devote to it.

That’s when I saw this little device called the Netduino which runs something called the .NET Micro-framework. This seems just what I’ve been looking for. A microcontroller device that I can put together a few electronics items which are available off-the-shelf and write some .NET code in my language of choice (VB) to implement some basic functionality.

So the next question is what did I think would be a good first project?

My wife is studying to be a sommelier which means we have quite a few bottles of wine in the house. Sometimes we open one up an it’s developed a fault. Now there are numerous reasons for wines developing faults but incorrect storage is one possible cause. Wine is very temperamental and is best stored in a cool dark climate that doesn’t change much through the seasons which is why cellars or caves are great for storage but unfortunately in normal modern houses a cave or wine cellar is not a standard item. So we use our pantry to store our wine.

With this in mind I wanted to be able to know if the pantry conditions were really fluctuating that much. So I had my project but where to start? A simple device to monitor the wine cellar (eer pantry!!!) and provide warning indications of hi or low temperature conditions.

Well the first thing was to look around and find the parts I would need – a Netduino Plus device was chosen because it has networking capabilities built in which I would use later. A prototyping shield and a few electronic components such as temperature and humidity sensor and some LED’s to indicate status.

The Netduino hardware is a micro-controller running a very small version cut down version of the .NET framework called the Micro-Framework. This enables .NET developers to write their application code using C# and recently added VB.NET. Allowing you to write you application as high level code dealing with the problem rather than having to resort to using low level assembler to control the hardware. There are some things that a not implemented with Generics / Late Binding being the obvious two but the code is clearly VB.NET / C# and you use Visual Studio as a development tool.

The device is made in such a way that you can plug in shields. Shields are really circuit boards that conform to a specific physical layout. These shields contain all the necessary circuitry to do a specific tasks such as SD Card reader/writer, Wi-Fi networking or can be a blank one which allows you to create your own circuitry either by soldering up components or by using a prototyping breadboard.

So after a little research located the parts I need would need and the basic circuitry to do get the sensors and LED’s connected. It’s easy enough to find this information with vendors such as Sparkfun, MakerShed, Adafruit all having lots of useful information as well as the Netduino website community forums having lots of information on sensors used by people and code snippets.

With all this in hand I constructed a basic shield – very simple for anyone that has done any basic soldering. If you can’t, it’s real easy to learn. With Netduino and prototyping shield in hand I launched Visual Studio to write some code to make my monitoring device come to life.

The applicable needs to do a number of tasks

· Read the sensors
· Write the data to the SD Card
· Detect any temperature warning conditions.
· Provide visual indications of working and warning conditions
· Provide a reset capability

My approach was to take each task and build an evolving system. So the first thing was to wire up the sensor and the LED’s. Using a breadboard makes it real easy and is really a case of plugging wires in to make the connections.

The design looked like the following. It looks a bit crazy when prototyping but I’ll eventually clean this up before putting the item in the pantry and having a worried wife come tell me there is a mysterious device with wires coming out of it in the pantry.

Connections

(Some of these may be not requiring connections because they are implemented as part of the prototyping shield. Examples of this are my reset button and heartbeat and reset LED’s which only required the Dx output. The ground wires were already implemented as part of the shield.)

Item		Connection
TMP36 Sensor		3.3v and ARef (if using a RevA board)
		A0
		Ground

Hi Warning LED		D9
		Ground

Low Warning LED		D11
		Ground

Heartbeat LED		D13
		Ground
Button		D8
		Ground
Reset LED		D12
		Ground

Now to make it work and write some code.

The micro framework is really a lightweight version optimized for embedded device development. VB support is a recent addition and required the 4.2 version of the micro framework to be installed along with the firmware update to the Netduino. Updating the firmware to 4.2 was a breeze.

So let’s break development into a few simple tasks one at a time. Each task I’ll show code snippets but the entire finished source is available to download.

Reading the sensor

The code for this application is a simple Console application which is running indefinitely. As I’m powering the final device by means of a 9v battery I want to do enough to get the job done but want to make sure that I have sufficient battery life. So I will be taking a reading every 10 minutes which means that most of the time the device is really asleep.

There are both analogue and digital temperature sensors. Mine original sensor is a simple thermistor (Temperature dependent resistor) which means that the resistance varies with temperature changes. Using the Analogue input ports on the Netduino in conjunction with this allows me to determine a temperature. There are two revisions of the Netduino (Rev A and Rev B). The significant difference between the two is related to Analogue references and the need to provide an extra link between the 3.3v pin and the Aref0 pin – without this the values read on the Analogue port will be inconsistent. Luckily almost all boards out there are Rev B boards with this already internally connected on the board preventing you from having to remember this.

The formula for calculating a temperature is as follows….

This code will create a timer which raises an event every x seconds and takes a temperature reading. As there are some minor variations in reading a single instantaneous value, my approach was to take a number of readings over a short period of time and average them out. This should flatten any rogue values that occurred. When debugging this I set a shorter period to ensure that I could see this process working.

I’d also included debug values to be able to monitor the temperature value it was reading. These can be conditional compiled out in final release version. The values seemed a little high on this sensor so I located a second sensor and installed this and measured the temperature reading on this and was able to adjust the first. This may have been possible by adding a resistor in the circuit for the original sensor but I was able to experiment using and offset value in code to calibrate this and it seemed accurate enough.

Imports Microsoft.SPOT
Imports Microsoft.SPOT.Hardware
Imports SecretLabs.NETMF.Hardware
Imports SecretLabs.NETMF.Hardware.Netduino

Public Module Module1
    Dim PollingDelay As Integer = 2
    Dim tempSensor As New AnalogInput(Pins.GPIO_PIN_A5)
    Dim CurrentTemperature As Double = 0

    Public Sub Main()
        Dim Temperature As Double = 0

        '//Setup Event Handlers
        PollingTemperatureMethod()

        '//Get the initial temperature
        CurrentTemperature = GetAverageTemperatureReading()
        While True
            Thread.Sleep(Timeout.Infinite)
        End While
    End Sub

   Function GetCurrentTemperature() As Double
        ''Read the raw sensor value
        Return tempSensor.Read()
    End Function

    'Get the average temperature of 101 readings over a second
    Function GetAverageTemperatureReading() As Double
        Dim totalTemp As Double
        Dim averagetemp As Double = 0

        For i = 0 To 99
            totalTemp += GetCurrentTemperature()
            Thread.Sleep(10)
        Next
        averagetemp = totalTemp / 100

        Dim Kelvin As Double = (((averagetemp / 1023) * 3.3) * 100)
        Dim Celsius As Double = (Kelvin - 273) - 17.8
        Dim Fahrenheit = (Celsius) * (9 / 5) + 32

        Debug.Print(WarningStatus.ToString & " " & averagetemp.ToString() & " " & Fahrenheit.ToString & " / " & Celsius.ToString & " ")

        Return Celsius
    End Function


    Private PollingTimer As Timer

    Private Sub PollingTemperatureMethod()
        Dim PollingDelegate As New TimerCallback(AddressOf PollForTemperature)
        PollingTimer = New Timer(PollingDelegate, Nothing, 1000, PollingDelay * 1000)
    End Sub

    Public Sub PollForTemperature(stateInfo As Object)
        Module1.CurrentTemperature = GetAverageTemperatureReading()
    End Sub

End Module

Writing the SD Card

There are a few differences between the Netduino and the Netduino Plus. I’d chosen the Plus version because it comes with a micro SD card slot on the board – so no new hardware are required to log these values for reviewing later. Searching in the Netduino forums reveals many examples of code available to write to SD Cards. The micro-framework includes some IO file support but is not the file support that you might expect from the full desktop .NET Framework. The task I want to achieve is to append the new sensor readings to the end of a file containing the existing readings and using the full framework I’d simply be using the System.IO.File class but this doesn’t exist on Micro-framework and so I had to create my own helper function which uses a Streamwriter, I guess once I’ve done this once I can reuse it over again.

Added to PollForTemperature Method

        Dim Str As String = "SensorData: 1," & Module1.CurrentTemperature.ToString & "2," & Module1.CurrentTemperature2.ToString
        AppendToFile("\SD\Temperature.dat", Str)
        


#Region "Writing Data to SD Card"
    Private Function VolumeExist() As Boolean
        Dim volumes As VolumeInfo() = VolumeInfo.GetVolumes()
        For Each volumeInfo__1 As VolumeInfo In volumes
            If volumeInfo__1.Name.Equals("SD") Then
                Return True
            End If
        Next
        Return False
    End Function

    ' Append to a file / Create the file if it doesn't exist
    Private Sub AppendToFile(filename As String, string1 As String)
        If Not VolumeExist() Then
            Return
        End If

        Try

            Dim fs As FileStream = If(File.Exists(filename), New FileStream(filename, FileMode.Append), New FileStream(filename, FileMode.Create))
            Dim streamWriter As New StreamWriter(fs)
            streamWriter.WriteLine(string1.ToString)
            streamWriter.Flush()
            streamWriter.Close()

            fs.Close()
        Catch generatedExceptionName As Exception
        End Try
    End Sub
#End Region

Detecting Warning Conditions

I wanted my code to be able to detect hot and cold warning conditions as both of these can cause problems with wine storage. During development I wanted a much narrower temperature range allowing me to trigger it easily but chose to read these settings into the application from a file on the SD Card to make it flexible. Allowing me modify the settings without having to redeploy the application. Once I have these Maximum and Minimum values I can then use these to determine if the sensor reading is a Warning Condition and if this has occurred turn on one of the two warning LED to provide a clear indication that we have had an temperature event occur.

Dim HiWarningLED As New OutputPort(Pins.GPIO_PIN_D9, False)
Dim LowWarningLED As New OutputPort(Pins.GPIO_PIN_D11, False)

Public Enum LevelCheck
    LowTemp
    HiTemp
End Enum

    Dim LowWarningStatus As Boolean = False
    Dim WarningStatus As Boolean = False
    Dim MinTemp As Single = 20
    Dim MaxTemp As Single = 26

    Function CheckTemperatureForWarning(Temp As Double, Optional Level As LevelCheck = LevelCheck.HiTemp) As Boolean
        Dim WarnStateOccured As Boolean = False
        If Level = LevelCheck.LowTemp Then
            'Is Temperature Exceeding MaxTemp
            If Temp <= MinTemp Then
                Debug.Print("Low Warning Triggered")
                Debug.Print("Temp: " & Temp.ToString)
                Debug.Print("maxTemp: " & MaxTemp.ToString)
                Debug.Print("minTemp: " & MinTemp.ToString)
                WarnStateOccured = True
            End If
        ElseIf Level = LevelCheck.HiTemp Then
            'Is Temperature Exceeding MaxTemp
            If Temp >= MaxTemp Then
                Debug.Print("Hi Warning Triggered")
                Debug.Print("Temp: " & Temp.ToString)
                Debug.Print("maxTemp: " & MaxTemp.ToString)
                Debug.Print("minTemp: " & MinTemp.ToString)
                WarnStateOccured = True
            End If
        End If
        Return WarnStateOccured
    End Function


    Sub WarningStatusLight(State As Boolean, Optional Level As LevelCheck = LevelCheck.HiTemp)
        'Code to turn on/off LED
        If Level = LevelCheck.LowTemp Then LowWarningLED.Write(State)
        If Level = LevelCheck.HiTemp Then HiWarningLED.Write(State)
    End Sub


Public Sub PollForTemperature(stateInfo As Object)
        Module1.CurrentTemperature = GetAverageTemperatureReading()

        'If the warning status light is off and a warning temperature occurs then 
        'set Warning Light State to True and don't bother checking any more as the 
        'alarm condition has been met
        If LowWarningStatus = False AndAlso CheckTemperatureForWarning(CurrentTemperature, LevelCheck.LowTemp) = True Then
            LowWarningStatus = True
            WarningStatusLight(LowWarningStatus, LevelCheck.LowTemp)
        End If

        If WarningStatus = False AndAlso CheckTemperatureForWarning(CurrentTemperature, LevelCheck.HiTemp) = True Then
            WarningStatus = True
            WarningStatusLight(WarningStatus, LevelCheck.HiTemp)
        End If
End Sub

Reset Button

When a temperature event has occurred I can retrieve the SD Card and determine how high and for how long this event occurred. But I would like a simple way to reset the LED. I could just repower the device which would restart everything back to its original state or a more elegant way is simply to have a Reset Button to turn the LED off – so I’d implemented a solution which would reset the warning indicator LED and provide feedback with a little flashing sequence. One important thing to note is that when the button pressed interrupt occurs it is necessary to re-enable the interrupt. This is something that you don’t normally have to do with other button click events.

    Dim button As New InterruptPort(Pins.GPIO_PIN_D8, False, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeBoth)
    Dim ResetLED As New OutputPort(Pins.GPIO_PIN_D12, False)

    Sub SetupResetButtonHandler()
        AddHandler button.OnInterrupt, AddressOf ResetStatusLight
        button.EnableInterrupt()
    End Sub

    Sub ResetStatusLight(ByVal data1 As UInteger, ByVal data2 As UInteger, ByVal time As Date)
        Debug.Print("Reset Warning Light")
        If data2 = 0 Then
            ResetLED.Write(True)
            Dim LEDFlashState As Boolean = False
            For i = 0 To 8
                ResetLED.Write(LEDFlashState)
                Thread.Sleep(100)
                LEDFlashState = Not LEDFlashState
            Next
            ResetLED.Write(False)
        End If

        button.EnableInterrupt()
    End Sub

Heartbeat Indicator

When testing the functionality I realized this device could be sitting in my pantry working away and the temperature could be just fine OR the battery could be flat and I would have no obvious signs to differentiate the two. The location of the shield on top of the device hides a little LED on the main Netduino board. So, I decided that a heartbeat LED flashing every minute would be a good idea on providing visual indication the sensor was alive and working.

Dim HeartBeatLED As New OutputPort(Pins.GPIO_PIN_D13, False)

    Private watchdogTimer As Timer
    Private HeartBeatThread As Thread = Nothing

    Private Sub HeartBeatThreadMethod()
        Dim HeartBeatDelegate As New TimerCallback(AddressOf PulseLED)
        watchdogTimer = New Timer(HeartBeatDelegate, Nothing, 1000, HeartBeatDelay * 1000)
    End Sub

    Public Sub PulseLED(stateInfo As Object)
        Debug.Print("HeartBeat...")
        HeartBeatLED.Write(True)
        Thread.Sleep(250)
        HeartBeatLED.Write(False)
        Thread.Sleep(250)
        HeartBeatLED.Write(True)
        Thread.Sleep(250)
        HeartBeatLED.Write(False)
    End Sub

Debug

With this code in place I can now debug the application. Simply pressing F5 will compile and debug the application. As the device doesn’t have a UI as such, we can use Visual Studio when debugging on a device to monitor values of variables etc. just as we would on a desktop application. This enables me to code step code to trace through the code and find logic issues as well as write additional debug output to the Output window.

The experience is very similar to the desktop – although no edit and continue is permitted. This is ok as the applications as small and you are essentially deploying them completely to the device each time you are debugging your application. The deployment is very quick as the applications are measured in kilobytes. The important thing to check is that you are deploying to the device – Project Properties > .NET Micro-framework Tab -> USB -> Netduino_Plus is selected.

Deploy

Deploying your application is automatically accomplished by debugging your application. The process involves a couple of additional steps in translating your IL into code which will run on the specific micro-framework device but these details are more to do with the hardware platform vendors SDK hooking into Visual Studio. Although .NET Micro-framework supports hardware emulators for testing – it is simple to debug on the device itself – albeit it takes a few seconds longer to deploy the application to the physical device.

Summary

I now have a basic functioning sensor that I can used to retrieve sensor readings from my Wine Cellar which will give me a visual indication of spoilage temperature conditions. I’ve managed to read a build a circuit, read a sensor, use timers to poll for reading, turn on/off LED’s for Visual Indication, Interact with device via a button input and write data to a Micro SD Card. These are basic functions which can be used over and over again in many different applications.

We’ll take this one step further and enable the Wifi support to allow remote reading of the device.

Spotty

Additional Info

Netduino micro-controller

www.Netduino.com

Electronic Components Suppliers

www.AdaFruit.com

www.Makershed.com

www.Sparkfun.com

Download Locations

Micro-framework 4.2 Beta	http://netmf.codeplex.com/
Netduino Firmware	http://forums.netduino.com/index.php?/topic/1958-netduino-firmware-v420-beta-1/

Kinect SDK For PC - VB Samples available.

VBTeam — Thu, 16 Jun 2011 20:43:00 GMT

Today, Microsoft announced the Kinect SDK for PC

http://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/download.aspx

VB Samples are there at launch and available for downloading

http://files.ch9.ms/coding4fun/KinectSDKSamplesVB.zip

Micro-framework v4.2 Support for Visual Basic

VBTeam — Thu, 09 Jun 2011 03:17:16 GMT

The release of .NET Micro framework v4.2 Beta brings Visual Basic support for the .NET Micro-framework.

For those that have not heard of the Micro framework before

“The .NET Micro Framework is .NET for small and resource constrained devices. It offers a complete and innovative development and execution environment that brings the productivity of modern computing tools to this class of devices.

For current .NET developers, this means that they can now create applications that run on a range of devices from targeted devices like remote controls to PCs and Servers and on to the cloud – all with the same programming model and tools.

For current Embedded developers, this means that they can now leverage the productivity gains that have been achieved on the desktop and reduce their time to market.

The .NET Micro Framework is a fully integrated Visual Studio experience brings a reliable and productive development system to the embedded world.”

Up until now the platform has been a C# only platform but the v4.2 Beta brings VB support. The support requires the installation of Visual Studio 2010 SP1 installations (Express versions support is not yet implemented fully). The VB support utilizes the work carried out by the 'Compilers' team for VBCore functionality and lights up another platform. This is exciting news for both the Compilers and the .NET Micro-framework teams

Other hardware vendor SDK’s will be available updating their SDK and providing specific VB project templates target 4.2, with Secret Labs already releasing a 4.2 Beta version of their SDK for the Netduino devices with VB support.

This is really exciting news for anyone that wants to get into the area embedded microcontroller devices and wanting to leverage their VB skills and tinker with some electronics. VB developers can now be microcontroller developers.

More info to follow...

Download Location
http://netmf.codeplex.com

Addition Info

Micro-Framework Team Blog
http://blogs.msdn.com/b/netmfteam/archive/2011/06/07/netmf-version-4-2-beta-now-available.aspx

.NET Micro-framework
http://www.microsoft.com/en-us/netmf/default.aspx

Secret Labs Netduino
http://www.netduino.com

VB Support for the XNA platform

VBTeam — Wed, 25 May 2011 20:16:42 GMT

With the release of the Mango Toolset, Visual Basic support for XNA and Windows Phone has now been added. VB resources include VB XNA documentation and VB WP7 code samples and starter kits and this post is intended to walk you through some of the steps in creating a simple XNA application for Windows Phone 7 using VB.

What is XNA?

Microsoft XNA is the development framework and tools used to create application for the Xbox 360 / Desktop PC and also the windows Phone 7. It provides access to build managed game type applications. The goal as with any framework is to avoid the developer having to write a lot of low-level repetitive boilerplate code and to expose different aspects of game production into a single system.

The XNA toolset is not new although it has undergone a number of revisions. Although during its history it has only supported C# as a development language for a number of technical reasons, although some users managed to create workarounds to allow limited support. However with the advent of the Windows Phone 7 and its use of the XNA framework additional efforts were made to ensure Visual Basic developers were not left out of the game and with the Mango Tools update finally VB users are provided with full support within XNA.

Why is it important?

Windows Phone 7 as a platform is extremely important for Microsoft. The mobile platform had a fundamental reset to provide a much improved user experience. There are two different ways of developing applications for the platform - Silverlight and XNA.

The Silverlight support was implement a while back with specific project templates for the phone but XNA had a few more challenges which have required a bit more work. Silverlight is ideal for most applications that are not timing critical and works well in an event driven model, this is most similar to the type of applications most existing VB developers have created for Windows or the Web. Events are triggered (such as user clicking a button), code is then executed. However for many games, timing is obviously critical and this requires a different platform designed specifically for this type of application. This is best shown with the following diagram which shows the concept of the "Game Loop" – with more details shown a little bit later.

This post is only intended to show you how to get started with XNA development using Visual Basic. To fully realize the potential would take many more pages - entire books devoted to the subject have been written.

How do I use it?

The first thing to do is install the Windows Phone Developer Tools 7.1 Beta’ (Mango Toolset) onto a machine with Visual Studio 2010 SP1 installed. VS2010 SP1 is critical for this to work and also will change how Silverlight application developed using VB are now compiled. This will also install updated Windows Phone 7 templates.

Be aware that XNA requires a higher-end video card to allow the emulator to run; most modern machines have cards capable of supporting DirectX10 and 11 which should be sufficient. This is important as Silverlight applications using the emulation don’t require the higher end video card.

Let’s create something using VB and XNA

The first thing you will notice is when you create a new project that there is now a folder containing marked "XNA Game Studio 4.0" as well as the existing "Silverlight for Windows Phone 7" folder.

So let’s start by selecting "Windows Phone 7 4.0 Game" to demonstrate XNA.

The first thing you will notice that this Project type actually created 2 projects, a game project and a content project.

This post is working through a simple game application using XNA in order to show VB support. Although when running using the emulator you will not see the true experience, the application will be using the accelerometer sensor inputs of the phone when deployed to a windows Phone 7 device.

So the example is going to have a "Yoyo" type object that is bouncing around the screen and controlled by user inputs. The application will use some simple physics to implement the spring type functionality. Although this is really only a rough approximation of the physics involved it does utilize some items to simulate friction, gravity.

One of the main differences between typical VB "Event driven" applications and XNA "Game Type" applications is that for XNA - timing is absolutely critical. The XNA type applications generally follow a code flow similar to the following. The main bulk of the code is contained within the “Game Loop” cycle of Update/Draw.

The frame rate for the game equates to the speed at which the game loop is running - obviously we want to make the application appear fluid which involves setting one high enough that the animation is going to look smooth. Too low a value and the animate will look jerky, too high a value and the application can get bogged down in calculations which are really not perceptible and the more unnecessary processing the application is doing, the shorter the battery life will be - so there are trade-offs that are made.

The good thing about this frame rate is that it can be controlled really easily and doesn’t really involve having to a lot of low level code. By default the frame rate normally used is roughly 30 frames per second. This is slightly quicker than what the average person can detect and therefore animation at this rate appears smooth.

This can be altered by modifying the line

TargetElapsed = Timespan.FromTicks(3333333)

Now this has been established we need to add a couple of resources used by the application. We will add these to our “Content” Project. We will add the following existing items to the Content project.

Yoyo.png
PieceOfString.Bmp
Target.png

To add the images, simply add using "Add an Existing Item" context menu options from solution explorer and selecting the images files. These items are now part of the content project. Not all graphic image formats are supported so you will need to be careful to select one that is. This is an important point that not all formats are supported for all actions. This relates to graphics/sounds etc. but this information is easily found within XNA links.

Next let’s open up game.vb in the game project and add a few fields which we are going to use for the application. These will be used to hold items required for the game.

Private WithEvents graphics As GraphicsDeviceManager
Private WithEvents spriteBatch As SpriteBatch

'//stores accelerometer's acceleration
Dim accelerometer As Microsoft.Devices.Sensors.Accelerometer
Dim accelX As Single = 0
Dim accelY As Single = 0
Dim spring As Single = 0.2
Dim friction As Single = 0.75
Dim gravity As Single = 17

'Finger Coordinates
Dim fingerPosition_X As Single = 0
Dim fingerPosition_Y As Single = 0

'Yoyo Object
Dim YoYo As Texture2D
Dim PieceOfString As Texture2D
Dim YoYo_Position_X As Single = 50
Dim YoYo_Position_Y As Single = 50
Dim YoYo_VelocityX As Single = 0
Dim YoYo_VelocityY As Single = 0

'Text Position and Score
Dim font1 As SpriteFont
Dim font_Position As Vector2
Dim ScreenCenter As Vector2
Dim textsize As Vector2
Dim Text As String = "Yoyo Attack" & vbLf & "by Spotty"

This has defined some basic items for our game but based upon the general flow diagram show above we will need to put some lines in the “LoadContent” method to use the content which we have already added into the content project (ie. Yoyo.png, PieceOfString.bmp)

We need to Load the content for our game application. The content is stored in the Content Project but when creating a new game, an automatic project to project reference was created between the two. So in the Game project, the “LoadContent” method will have the following code added initialize our game objects with the correct content.

Protected Overrides Sub LoadContent()
    ' Create a new SpriteBatch, which can be used to draw textures.
    spriteBatch = New SpriteBatch(GraphicsDevice)
    YoYo = Content.Load(Of Texture2D)("Yoyo")
    PieceOfString = Content.Load(Of Texture2D)("PieceOfString")

    font1 = Content.Load(Of SpriteFont)("CourierNew")
    Dim viewport As Viewport = Me.GraphicsDevice.Viewport
    ScreenCenter = New Vector2(viewport.Width / 2, viewport.Height / 2)
    Text = "Yoyo Attack" & vbCrLf & "By Spotty"
    textsize = font1.MeasureString(Text)

End Sub

As the phone is a specific type of device that runs XNA (From the project templates you will have noticed you can target windows, Xbox 360 and Windows Phone 7 using XNA), for the purposes of this application we want to use the accelerometer on the phone so we will need to add a reference to allow us to capture this sensor input.

This requires the addition of the Microsoft.Devices.Sensors.dll in the “Game” project which is a specific class library used for Sensor inputs on the phone. This should show up in the list of applicable references shown on the add references dialog.

So within the Game Project Initialize Method we will add the following

Protected Overrides Sub Initialize()
    font_Position = New Vector2(graphics.GraphicsDevice.Viewport.Width / 2 - 100,     graphics.GraphicsDevice.Viewport.Height / 2)

    If accelerometer Is Nothing Then
        '// Instantiate the accelerometer sensor
        accelerometer = New Microsoft.Devices.Sensors.Accelerometer

        AddHandler accelerometer.ReadingChanged, AddressOf accelerometer_ReadingChanged
        accelerometer.Start()
    End If
    MyBase.Initialize()
End Sub

At this point you will notice a compile error on the AddHandler line because we don’t have a method called “Accelerometer_ReadingChanged” so we can use the “Generate from usage (GFU)” feature. This will generate a method with the following signature.

Private Sub accelerometer_ReadingChanged(sender As Object, e As Microsoft.Devices.Sensors.AccelerometerReadingEventArgs)

End Sub

Within this method we will add a few lines of code to set the acceleration fields with values which are used in the update method.

accelX = CType(e.X, Single)
accelY = CType(e.Y, Single)

So we now have much of the basic parts of the application but we still have not drawn anything on the screen. We are now going to code up the two major methods used for the game loop (update and draw)

So the first method which we will code up is the Update method.

Protected Overrides Sub Update(ByVal gameTime As GameTime)

        ' Allows the game to exit
        If GamePad.GetState(PlayerIndex.One).Buttons.Back = ButtonState.Pressed Then
            Me.[Exit]()
        End If

        'get the state of the touch panel
        Dim curTouches As TouchCollection = TouchPanel.GetState()

        ' Process touch locations
        For Each location As TouchLocation In curTouches
            Select Case location.State
                Case TouchLocationState.Pressed
                    fingerPosition_X = location.Position.X
                    fingerPosition_Y = location.Position.Y
                    Exit Select
                Case TouchLocationState.Released
                    'Don't care about released state in this demo
                    Exit Select
                Case TouchLocationState.Moved
                    fingerPosition_X = location.Position.X
                    fingerPosition_Y = location.Position.Y
                    Exit Select
            End Select
        Next

        Dim ax As Single = (fingerPosition_X - YoYo_Position_X) * spring
        Dim ay As Single = (fingerPosition_Y - YoYo_Position_Y) * spring

        'Calculate Yoyo velocity based upon Finger acceleration, gavity and friction coefficients
        YoYo_VelocityY += ay
        YoYo_VelocityY += gravity * accelY
        YoYo_VelocityY *= friction

        YoYo_VelocityX += ax
        YoYo_VelocityX += -gravity * accelX
        YoYo_VelocityX *= friction


        'Calculate Yoyo Position based upon velocity
        YoYo_Position_X += YoYo_VelocityX
        YoYo_Position_Y += YoYo_VelocityY

        MyBase.Update(gameTime)
    End Sub

The calculation of the yoyo velocity may seem a little complicated but it is based upon 3 factors Finger acceleration which is set as a result of the event we have just hooked up and the gravity and friction coefficient fields which we have established in the field declarations.

The method is calculating the Yoyo position based upon these inputs as well as determining if the back button as been pressed on the phone.

So now we have calculated our new position for the Yoyo, we need to draw the item.

Protected Overrides Sub Draw(ByVal gameTime As GameTime)

        Dim start As New Vector2(fingerPosition_X, fingerPosition_Y)
        Dim [end] As New Vector2(YoYo_Position_X, YoYo_Position_Y)
        Dim rotation As Single = CSng(Math.Atan2([end].Y - start.Y, [end].X - start.X))

        'calculate the distance between the start and end points
        Dim distance As Integer = CInt(Vector2.Distance(start, [end]))

        GraphicsDevice.Clear(Color.Navy)  
        spriteBatch.Begin()

        'Yoyo Drawing
        If PieceOfString IsNot Nothing Then
            spriteBatch.Draw(PieceOfString, start, Nothing, Color.Gray, rotation, Vector2.Zero, _
                 New Vector2(distance, 1.0F), SpriteEffects.None, 0.0F)
        End If
        spriteBatch.Draw(YoYo, New Vector2(YoYo_Position_X - YoYo.Width / 2, YoYo_Position_Y - YoYo.Height / 2), Color.White)


        'Position Titles On Screen
        font_Position.X = ScreenCenter.X
        font_Position.Y = ScreenCenter.Y

        spriteBatch.DrawString(font1, Text, font_Position, Color.Bisque, MathHelper.ToRadians(270), Nothing, 1, SpriteEffects.None, 0)

        spriteBatch.End()

        MyBase.Draw(gameTime)
    End Sub

And last but not least we need to correctly clean up our application when it closes which requires calling out Content dispose methods

    Protected Overrides Sub UnloadContent()
        YoYo.Dispose()
        PieceOfString.Dispose()
        target.Dispose()
    End Sub

So now we can debug the application, this will start up an instance of the emulator. As we don’t have a physical device we can use the mouse to click on the emulator and flick the Yoyo around. It works like a spring and we have written the code to control this, but it’s not very game-like and we want to add some more game features.

So we will create a simple item which well to create a 2nd item that will bounce around the screen and act as a target. This object has less physical properties but will have simple X/Y fixed velocity to determine its movement characteristics but will introduce boundaries and collision detection. A critical point here is that adding this 2nd item should absolutely NOT result in the game slowing down noticeable.

So we will add a few more fields used to store important data of the Target object.

   'Target Object
    Dim target As Texture2D
    Dim TargetX As Single = 10
    Dim TargetY As Single = 10
    Dim TargetVelocityX As Single = 7
    Dim TargetVelocityY As Single = 10
    Dim TargetRadius As Single = 0

Then add need to add some content for the target object. So we will add Target.png to the content project and add code to Game project “LoadContent” method to ensure that we initialize the Target object with an appropriate image from Content project.

target = Content.Load(Of Texture2D)("Target")

The next thing we need to do is control is the ability of the Target Object to detect when it has reached the edge of the screen and make it appear to bounce of the edge. The important thing here is that that the Target object has two important items associated with it (Vector2D to control direction of movement and Texture2D that determines the appearance of the object such as size, content etc.). Based upon the field initialized values we have some initial values but these will change when it hits the edge so we need to write a little code.

For the physics we will assume that this object has zero friction and a fixed velocity. This should make implementing it a little easier. We will need to add some logic in the Update method to ensure we are calculating its new position. This code will need to include some logic to determine if it has reached the edges of the screen and the rebound behavior. Think of a Pool table and the ball bouncing off the edges.

So I’ll add an Enumeration for Direction

Public Enum Direction
    Up
    Down
    Left
    Right
End Enum

And in add a couple more fields

Dim x_Direction As Direction = Direction.Down
Dim y_Direction As Direction = Direction.Left

This will be used to determine the direction of travel in the collision detect logic. We can then create a simple method to control the Edge bounce behavior of the target object.

Private Sub DetectTargetEdgeBounce()
        If TargetX < 0 Then
            'If hit Top Edge then
            x_Direction = Direction.Down
        ElseIf TargetX > GraphicsDevice.Viewport.Width Then
            'Else IF Hit Bottom Edge then
            x_Direction = Direction.Up
        End If

        If TargetY < 0 Then
            'If hit Top Edge then
            y_Direction = Direction.Right
        ElseIf TargetY >= GraphicsDevice.Viewport.Height Then
            'Else IF Hit Bottom Edge then
            y_Direction = Direction.Left
        End If

        'Determine new coordinatied based upon direction
        If x_Direction = Direction.Down Then
            TargetX = TargetX + TargetVelocityX
        ElseIf x_Direction = Direction.Up Then
            TargetX = TargetX - TargetVelocityX
        End If

        If y_Direction = Direction.Right Then
            TargetY = TargetY + TargetVelocityY
        ElseIf y_Direction = Direction.Left Then
            TargetY = TargetY - TargetVelocityY
        End If
    End Sub

The logic I have implemented is easy as it treats the X border detection and Y border detection as separate conditions and reverses the direction of travel when a collision is detected. There are many other ways of achieving the same logic but this is easy to understand.

We now need to make a couple more additions to the Update and draw methods. The following line should be added to the “Update” method calculate the new coordinate of the object based upon current coordinate, direction of travel, Velocity and screen size.

DetectTargetEdgeBounce() 'Movement of Target

Now we have determined the new position of the target object by called the “DetectTargetEdgeBounce” method, we need to ensure we draw it at this calculated position. This is as simple as adding the following lines to the Draw Method

spriteBatch.Draw(target, New Vector2(TargetX - Target.Width / 2, TargetY - Target.Height / 2), Color.Green)

So we now have two objects on the application - one is controlled by the user finger and exhibits some physical properties such as acceleration/gravity/Friction and the other is a much simpler one which appears to have no friction and fixed velocity that is bouncing off the edges of the screen.

We now have to implement a bit more logic to make it more game-like. This would involve some collision detection logic. We have a few logic items we want implement.

1. When Yoyo and target collide and the yoyo has velocity we score points.

2. The longer the collision duration the more points we score

3. We cannot touch the target – otherwise we will lose all points.

4. As we score more points the target becomes quicker.

As a result of this simple logic conditions we will change colors/Images, update score and play sounds. All these are elements of a simple game.

So let’s start with implementing some Collision Detection/Scoring code, as this is would appear to be the core component here. Each item has a single point representing it but obviously the image is bigger than that which is why we need to use both the Vector2d class for position and the Texture2d class for Size. As this seems to be something that we would want to keep together when referring to an game world “Object” , we can create a Type to represent this.

Structure WorldObject
    Sub New(Pos As Vector2, Texture As Texture2D)
        _Position = Pos
        _Texture = Texture
    End Sub
    Public Property _Texture As Texture2D
    Public Property _Position As Vector2
End Structure

We will also want to create a method to detect if these two items have collided based upon their positions and sizes. The following is a simple method which will determine a collision between two “WorldObject” Items, returning true if they have collided.

Public Function IsCollisonDetected(Item1 As WorldObject, Item2 As WorldObject) As Boolean
        'Determine Bounding Rectangle for Item1
        Dim Object_Item1 As New Rectangle(CInt(Item1._Position.X), CInt(Item1._Position.Y), Item1._Texture.Width, Item1._Texture.Height)
        Dim Object_Item2 As New Rectangle(CInt(Item2._Position.X), CInt(Item2._Position.Y), Item2._Texture.Width, Item2._Texture.Height)

        If Object_Item1.Intersects(Object_Item2) Then
            Return True
        Else
            Return False
        End If
    End Function

Now we have to add a little more code to determine the call this and determine some actions when a collision occurs. The first is to add a score field, which we will initialize with a zero value.

Dim Score As Integer = 0

Then in the “Update” method we will add the following code to call the IsCollisonDetected method for the various objects and determine if collisions have occurred between the Yoyo and Target objects and the Finger and Target objects.

So following code this should address the game logic items 1,2 ,3 and 4 in our list of game logic items.

        Dim YoyoObject As New WorldObject(New Vector2(YoYo_Position_X, YoYo_Position_Y), YoYo)
        Dim TargetObject As New WorldObject(New Vector2(TargetX, TargetY), YoYo)
        Dim FingerObject As New WorldObject(New Vector2(fingerPosition_X, fingerPosition_Y), YoYo)
        If IsCollisonDetected(FingerObject, YoyoObject) Then
            Score = 0        
        Else
            'Collision Detects 
            If IsCollisonDetected(TargetObject, YoyoObject) Then
                If CInt(YoYo_VelocityX) <> 0 OrElse CInt(YoYo_VelocityX) <> 0 Then Score = Score + 1                
                CollisionSound.Play(1, 0, 0)
            End If
        End If

        Text = "YoYo Attack" & vbLf & "by Spotty" & vbCrLf & "Score:" & Score.ToString & vbCrLf & "Time Remaining:" & CalculateTimeRemaining()

        UpdateTargetSpeed(Score)

We don’t have an UpdateTargetSpeed method so will use the GFU to generate a method and adding the following code within the method

Sub UpdateTargetspeed(Score As Integer)
        'Update Speed depending upon score
        Select Case Score
            Case Is < 10
                TargetVelocityX = 10
                TargetVelocityY = 10
            Case 11 To 20
                TargetVelocityX = 12
                TargetVelocityY = 12
            Case 21 To 30
                TargetVelocityX = 14
                TargetVelocityY = 14
            Case 31 To 50
                TargetVelocityX = 15
                TargetVelocityY = 15
            Case Is > 51
                TargetVelocityX = 20
                TargetVelocityY = 20
            Case Else
                TargetVelocityX = 10
                TargetVelocityY = 10
        End Select
    End Sub

So now we have a basic game – with some scoring, collision detection and functionality but we want to add a few more elements such as sounds. So let’s add a background sounds track and some collision detect sounds.

This is simply a matter of adding the audio content to the Content Project. In our example we can add the following three wav files to our Content Project – ( BackGroundMusic.wav, Tada.wav and Ding.wav), just as we did for our graphics used in the application. For our sounds we will have a background music track and then add some sounds into the “Update” method when collisions are detected.

We then simply need to add the following code in the “LoadContent” and “Update “Methods.

The following lines need to be added into the appropriate methods

Required Fields

    Dim BgSound As SoundEffect
    Dim BGInstance As SoundEffectInstance
    Dim CollisionSound As SoundEffect
    Dim TargetTouchSound As SoundEffect

“LoadContent” Method

    CollisionSound = Content.Load(Of SoundEffect)("Tada")
    TargetTouchSound = Content.Load(Of SoundEffect)("Ding")
    BgSound = Content.Load(Of SoundEffect)("BackgroundMusic")

    BGInstance = BgSound.CreateInstance
    BGInstance.IsLooped = True
    BGInstance.Volume = 0.5 'half Volume
    BGInstance.Play()

“Update” Method (Full Method Shown with additional lines enlarged)

Protected Overrides Sub Update(ByVal gameTime As GameTime)
        ' Allows the game to exit
        If GamePad.GetState(PlayerIndex.One).Buttons.Back = ButtonState.Pressed Then
            Me.[Exit]()
        End If

        'get the state of the touch panel
        Dim curTouches As TouchCollection = TouchPanel.GetState()

        ' Process touch locations
        For Each location As TouchLocation In curTouches
            Select Case location.State
                Case TouchLocationState.Pressed
                    fingerPosition_X = location.Position.X
                    fingerPosition_Y = location.Position.Y
                    Exit Select
                Case TouchLocationState.Released
                    'Don't care about released state in this demo
                    Exit Select
                Case TouchLocationState.Moved
                    fingerPosition_X = location.Position.X
                    fingerPosition_Y = location.Position.Y
                    Exit Select
            End Select
        Next

        Dim ax As Single = (fingerPosition_X - YoYo_Position_X) * spring
        Dim ay As Single = (fingerPosition_Y - YoYo_Position_Y) * spring

        'Calculate Yoyo velocity based upon Finger acceleration, gavity and friction coefficients
        YoYo_VelocityY += ay
        YoYo_VelocityY += gravity * accelY
        YoYo_VelocityY *= friction

        YoYo_VelocityX += ax
        YoYo_VelocityX += -gravity * accelX
        YoYo_VelocityX *= friction


        'Calculate Yoyo Position based upon velocity
        YoYo_Position_X += YoYo_VelocityX
        YoYo_Position_Y += YoYo_VelocityY

        DetectTargetEdgeBounce() 'Movement of Target


        'Detect Collisions
        Dim YoyoObject As New WorldObject(New Vector2(YoYo_Position_X, YoYo_Position_Y), YoYo)
        Dim TargetObject As New WorldObject(New Vector2(TargetX, TargetY), YoYo)


        Dim FingerObject As New WorldObject(New Vector2(fingerPosition_X, fingerPosition_Y), YoYo)
        If IsCollisonDetected(FingerObject, YoyoObject) Then
         TargetTouchSound.Play(1, 0, 0)
            Score = 0        
        Else
            If IsCollisonDetected(TargetObject, YoyoObject) Then
                If CInt(YoYo_VelocityX) <> 0 OrElse CInt(YoYo_VelocityX) <> 0 Then Score = Score + 1                
                CollisionSound.Play(1, 0, 0)
            End If
        End If

        Text = "YoYo Attack" & vbLf & "by Spotty" & vbCrLf & "Score:" & Score.ToString & vbCrLf & "Time Remaining:" & CalculateTimeRemaining()
        UpdateTargetspeed(Score)

        MyBase.Update(gameTime)
    End Sub

What’s not there in XNA / Phone applications?

We now have a basic game, with sound working on the phone using XNA. For those developers who may have tried experimenting a little with the basic code and using some of the other VB functions, you may have noticed that some expected items are found and others not. XNA uses a feature of the VB Compiler known as VB Core which embeds a reduced version of the Visual Basic runtime into the generated assembly. As this is a new platform for VB, many of these older legacy runtime functions contained in the desktop version of Microsoft.VisualBasic.dll do not exist in the VBCore runtime. Examples of this include the left, mid, right functions. This is intentional and provides VB support or the platform without unnecessarily bloating the assembly size with duplicate of existing framework functionality. So many of the types/functions etc. contained with the desktop versions Microsoft.VisualBasic.dll will not be present.

However, any as with any project types that utilizes the VB Core functionality, if you absolutely cannot live without some missing functionality you can add it simply by creating a method with the same name. Tools such as Reflector enable you to dissemble the code in Microsoft.VisualBasic.dll and see a source code equivalent for that function. Some functionality is not supported on new platforms using VBCore which also may be why they are not implemented – (a good example being Late Binding).

Other Changes

All phone projects now utilize the VB Core functionality to embed the required VB runtime functionality in your assemblies. This means that when you build your application (whether Silverlight or XNA) that there will no longer be a separate Microsoft.VisualBasic.dll that needs to be deployed as was the case with Silverlight Phone applications developed prior to the Mango Tools Update. To see this you can use a tool like ILDASM or Reflector to look at the assembly and you will now notice that the assembly now contains a Microsoft.VisualBasic namespace containing the reduced runtime.

To upgrade your existing windows phone 7 Silverlight projects to utilize this new feature, add the following line project file to

<VBRuntime>Embed</VBRuntime>

Also remove any reference to Microsoft.VisualBasic.dll from the .VBProj file.

Summary

XNA now fully supports Visual Basic on all platforms (Xbox360/Windows and Windows Phone 7). After completing this walkthrough VB developers should have an idea on how to write XNA applications. Although the model for developing game applications is different from that used by most VB Developers it is easy to get started. With the platform already well developed there are a huge number of resources available which VB Developers can use. VB developers can join the party and start creating to great applications using XNA.

Useful Web Links

· Windows Phone SDK Beta

Download Center: http://go.microsoft.com/?linkid=9772716
Go live license– http://go.microsoft.com/?linkid=9772717

· WPDT 7.1 Documentation

Windows Phone Developer Tools 7.1 Release Notes: http://go.microsoft.com/fwlink/?LinkId=215231
What’s New in Windows Phone Developer Tools: http://go.microsoft.com/fwlink/?LinkID=190409
Code Samples for Windows Phone: http://go.microsoft.com/fwlink/?LinkId=219604
· App Hub

Announcement: http://create.msdn.com/en-US/news/WPDT_7.1_Beta

Download page: http://create.msdn.com/en-us/resources/downloads

Getting Started: http://create.msdn.com/en-us/home/getting_started

· Blogs:

Spotty Bowles

Happy 20th Birthday Visual Basic!

VBTeam — Fri, 20 May 2011 23:08:00 GMT

Twenty years ago, May 20^th, 1991 at Windows World, in Atlanta, Microsoft founder Bill Gates demoed Visual Basic 1.0. Twenty years later, the 10^th version of this latest in an unbroken line of Microsoft BASIC languages stretching back to Microsoft’s founding is still going strong. When you look back over the history of a tool that’s been around that long you start to see some familiar experiences from Wetware products (commonly called children :P ): The cute and cuddly days of its youth, in the 16-bit era; the awkward teen years and the transition to .NET; sibling rivalry with the new baby (C#); and finally getting those braces … er, underscores off :). And now, finally out of those turbulent teen years, a matured language looks to the future. Visual Basic has always had a personality for humanizing programming and with Async methods in vNext it continues that tradition.

You might ask after two-decades how VB can keep re-inventing itself to face modern and future challenges. The answer is quite literally that – re-inventing itself. OK, more accurately re-writing itself. The VB compiler is being re-written from the ground up in Visual Basic and its syntactic and semantic analysis services exposed through a managed API that exposes parse trees, expression binding, assembly production (and more) to enable a world of new scenarios including REPL, VB as a scripting language, and more. It’s all very exciting! As a VB user for … half my lifetime, now, it’s great to look back and be proud of where VB has been, happy with where it is, and especially excited about where it’s going!

I have many fond memories of Visual Basic and likewise great aspirations for its future and I know millions of customers out there have the same. Please, share your stories (and hopes), and join me in wishing our old :P friend, VB, a Happy 20^th Birthday and many more! :D

Anthony D. Green
Program Manager
Visual Basic (code-name "Roslyn") Compiler

Simultaneous Async Tasks (Alan Berman)

VBTeam — Tue, 10 May 2011 16:00:00 GMT

The new Async feature in the Visual Studio Async CTP (SP1 Refresh) provides an elegantly simple technique to make code asynchronous.

Our writing team uses an internal app that would benefit from asynchronous calls. For each URL contained in the MSDN documentation that we publish, the app lists the title from the link, and the title parsed from HTML in the downloaded web page. We use the app to verify that URL links are valid.

The following example is a very simplified version of the relevant code, which does synchronous reads of multiple web pages.

Imports System.Net
Imports System.Threading.Tasks

Module Module1
Sub Main()
Dim urls As List(Of String) = BuildURLs()

Dim startTime = Date.Now

GetWebPagesSynchronous(urls)
'GetWebPagesAsync(urls).Wait()

Dim seconds = (Date.Now - startTime).TotalSeconds

        Console.WriteLine()
        Console.WriteLine("Ended in " & seconds & " seconds")
        Console.ReadKey()
    End Sub

Private Sub GetWebPagesSynchronous(urls As List(Of String))
Dim client As New WebClient

        For Each url In urls
            Dim text = client.DownloadString(New Uri(url))
            Console.WriteLine(GetTitle(text))
        Next
    End Sub

    Private Function GetTitle(input As String) As String
        Const startText = "<title>"
        Const endText = "</title>"

        Dim startIndex = input.IndexOf(startText)
        If startIndex = -1 Then
            Return "not found"
        Else
            startIndex += startText.Length
            Dim endIndex = input.IndexOf(endText, startIndex)
            Dim result = input.Substring(startIndex, endIndex - startIndex)
            Return result.Trim()
        End If
    End Function

    Private Function BuildURLs() As List(Of String)
        Return New List(Of String) From
            {
            "http://www.microsoft.com",
            "http://msdn.com"
            }
    End Function
End Module

The following method transforms the above example to use the Async feature. Starting with the above example, change Main to call GetWebPagesAsync(urls).Wait() instead of GetWebPagesSynchronous(urls).

In your project, add a reference to AsyncCtpLibrary.dll, which is in My Documents\Microsoft Visual Studio Async CTP\Samples.

Private Async Function GetWebPagesAsync(urls As List(Of String)) As Task

Dim theTasks As New List(Of Task(Of String))

For Each url In urls
Dim client As New WebClient()

Dim theTask As Task(Of String) =
client.DownloadStringTaskAsync(New Uri(url))

theTasks.Add(theTask)
Next

' Wait until the tasks are done.

    ' The Await statement causes execution to immediately return
    ' to the calling method, returning a new task. When all of the
    ' tasks complete, execution continues within this method.

    ' TaskEx.WhenAll would normally be Task.WhenAll.
    ' It's TaskEx.WhenAll in the CTP only.
    Await TaskEx.WhenAll(theTasks)

    For Each theTask In theTasks
        Console.WriteLine(GetTitle(theTask.Result))
    Next
End Function

For each URL in the list, the DownloadStringTaskAsync method returns a Task object that is then stored in a generic List. The code waits for completion of all of the tasks by using an Await statement and the Task.WhenAll method. The WhenAll method accepts an object that implements IEnumerable(T), including List(T).

The code spins up all of these tasks without worrying about running out of resources from a language perspective. I was inclined to write code to carefully throttle the calls to conserve resources, but was told that is unnecessary.

On computer running Windows 7, at a randomly convenient time, I ran the above console apps five times synchronously and five times asynchronously, with 20 URLs and 100 URLs. For 20 URLs, the average time to complete was 7.2 seconds for synchronous and 3.2 seconds for Async. For 100 URLs, the average was 39.5 seconds for synchronous, and 28.5 seconds for Async. With 100 URLs on another day, the average was 39.9 seconds for synchronous, and 13.5 seconds for Async. The results are specific to the conditions, and your results will vary.

Note that the speedup in the Async example is almost entirely from the parallel processing, not the asynchronous processing. The advantages of asynchrony are that it does not tie up multiple threads, and that it does not tie up the user interface thread.

Cancellation

The following example adds cancellation. To actually cancel the operation, modify the code to change cancelIt = False to cancelIt = True, and change the Thread.Sleep call to specify the milliseconds before cancellation.

This code creates a CancellationTokenSource that contains a CancellationToken. The same cancellation token is passed to every call to DownloadStringTaskAsync. The CancellationTokenSource is also used to invoke cancellation.

Imports System.Net
Imports System.Threading
Imports System.Threading.Tasks

Module Module1
Sub Main()
Dim urls As List(Of String) = BuildURLs()

Dim startTime = Date.Now

ProcessAsyncCancellable(urls)

Dim seconds = (Date.Now - startTime).TotalSeconds

        Console.WriteLine()
        Console.WriteLine("Ended in " & seconds & " seconds")
        Console.ReadKey()
    End Sub

Private Sub ProcessAsyncCancellable(urls As List(Of String))
Dim cts As New CancellationTokenSource()

cts.Token.Register(Sub() Console.WriteLine("cancelling"))

Dim theTask As Task = GetWebPagesAsync(urls, cts)

        ' To cancel midstream, set cancelIt to True.
        Dim cancelIt = False
        If cancelIt Then
            ' Set the milliseconds before cancelling.
            Thread.Sleep(2000)
            cts.Cancel()
        Else
            theTask.Wait()
        End If
    End Sub

    Private Async Function GetWebPagesAsync( _
    urls As List(Of String),
    cts As CancellationTokenSource) As Task

Dim theTasks As New List(Of Task(Of String))

For Each webAddress In urls
Dim client As New WebClient()

Dim theTask As Task(Of String) =
client.DownloadStringTaskAsync(New Uri(webAddress), cts.Token)

theTasks.Add(theTask)
Next

Await TaskEx.WhenAll(theTasks)

        For Each theTask In theTasks
            Console.WriteLine(GetTitle(theTask.Result))
        Next
    End Function

    Private Function BuildURLs() As List(Of String)
        Return New List(Of String) From
            {
            "http://www.microsoft.com",
            "http://msdn.com"
            }
    End Function
    Private Function GetTitle(input As String) As String
        Const startText = "<title>"
        Const endText = "</title>"

The above example displays all of the titles only when all of the tasks are complete. If you want to see the results before cancellation, you can replace GetWebPagesAsync with the following:

Private Async Function GetWebPagesAsync( _
urls As List(Of String),
cts As CancellationTokenSource) As Task

For Each webAddress In urls
Dim client As New WebClient()

Dim theTask As Task(Of String) =
client.DownloadStringTaskAsync(New Uri(webAddress), cts.Token)

        Await theTask
        Console.WriteLine(GetTitle(theTask.Result))
    Next
End Function

Thanks to Anthony Green, Alex Turner, Lucian Wischik, Mick Alberts, and Thomas Petchel for providing tech review.

Resources

The Temple of VB (Matt Gertz)

VBTeam — Fri, 29 Apr 2011 23:56:00 GMT

Hi, all!

It's been a while since I've posted to this blog, and a lot has happened in my world since then. Though I've been pretty busy on our engineering systems team, I took a little time off last summer to do some traveling and, more importantly, some long overdue writing.

Although I'd always enjoyed writing the "here's how you build this application" blog posts, I always felt that I could do a bit more with them, and so I took my favorite posts, cleaned them up, added a lot more text and pictures, and turned them into a Kindle e-book. The posts I've included and expanded on are: the Euchre game, the paint-by-numbers editor, the maze game, the gerbil game, the DNA-to-protein translator, and the encoder. (Since these posts were all written before VB2010 shipped, I've updated a couple of the walkthroughs to cover functionality that's been improved in VB2010 over earlier versions.)

You can find this book on Amazon now: "The Temple of VB: Six real-life applications to bring your Visual Basic .NET skills up-to-speed" by Matthew Gertz. And, of course, the source for the applications themselves is freely available at my Temple of VB site as usual. If you have a Kindle (or the Kindle for PC app) and are interested in a set of on-hand walkthroughs covering various coding areas (resources, printing, XML use, game logic, and so on), I invite you to take a look!

Addendum: A couple folks have reported that they can't get the links to work. Here are the links directly:

http://www.amazon.com/dp/B004YE78FS (for the book)

http://archive.msdn.microsoft.com/templeofvb (for the source code)

--Matt Gertz--*

P.S. If you have a smaller Kindle, like a Kindle 3, then I strongly recommend reading the book in landscape mode w/smaller font -- in general, lines of code look better that way, since they can wrap inelegantly in portrait mode on smaller screens.

The Visual Basic Team

Roslyn September 2012 CTP Available for Download!

Install Published Samples with Visual Studio

More VB Metro Samples available

Announcing Microsoft “Roslyn” June 2012 CTP

Kinect SDK v1.5 - Now with VB Samples !!!

Async Targeting Pack for Visual Studio 11, now available for .NET 4 and Silverlight 5

Visual Basic 11 Beta Available for Download!

New VB XNA Sample - showing Xbox, Windows and Phone targetting

VB Support for Microsoft Surface 2.0

Roslyn Syntax Visualizers

Putting back functionality left out of VB Core - ( If you can't live without Mid when writing WP7 apps ;-) )

Halloween: VB Style!

Introducing the Microsoft "Roslyn" CTP

Announcement: Namespace Global

Background

Problem

Namespace Global

Namespace Global: extension-method scenario

Namespace Global: codegen scenario

Namespace Global: under the hood of VB-Core

Namespace Global: specification

Visual Studio 11 Developer Preview: Visual Basic (VB) Call Hierarchy

Dynamics CRM 2011 Developer Training Kit - Updated with VB Source

Updated Samples for WP7 Developers

New Async Programming Video's

Temperature Monitoring using VB.Net, Micro-framework and a Netduino

Introduction

Connections

Reading the sensor

Writing the SD Card

Detecting Warning Conditions

Reset Button

Heartbeat Indicator

Debug

Deploy

Summary

Next:

Additional Info

Kinect SDK For PC - VB Samples available.

Micro-framework v4.2 Support for Visual Basic

VB Support for the XNA platform

What is XNA?

Why is it important?

How do I use it?

Let’s create something using VB and XNA

What’s not there in XNA / Phone applications?

Other Changes

Summary

Useful Web Links

Happy 20th Birthday Visual Basic!

Simultaneous Async Tasks (Alan Berman)

The Temple of VB (Matt Gertz)