The Visual Studio Blog

Bring Some Game To Your Code!

Visual Studio Blog — Wed, 18 Jan 2012 09:10:00 GMT

Bring Some Game To Your Code!

A software engineer's glory so often goes unnoticed. Attention seems to come either when there are bugs or when the final project ships. But rarely is a developer appreciated for all the nuances and subtleties of a piece of code--and all the heroics it took to write it. With Visual Studio Achievements Beta, your talents are recognized as you perform various coding feats, unlock achievements and earn badges.

Learn More About Visual Studio

Visual Studio is a powerful tool with tons of features, many of which you may not know about. Earning some of the badges may result in learning about features you didn’t even know existed!

Download It

Download it today from the Visual Studio Gallery

How It Works

With the Visual Studio Achievements Extension, achievements are unlocked based on your activity. Your code is analyzed on a background thread each time you compile. In addition, the extension listens for certain events and actions that you may perform in Visual Studio, reporting progress on these events to the server.

When you unlock an achievement, Visual Studio lets you know visually with a pop-up:

Figure 1 - Unlocking An Achievement

In addition, your Channel 9 profile is updated with any achievements you earn, recalculating your position on the leaderboard:

Figure 2 - The Visual Studio Achievements Leaderboard

Some examples of individual achievements include Regional Manager (have more than 10 regions in a single class), Close To The Metal (use 5 preprocessor directives), Stubby (generate method stubs 10 times) or Interrupting Cow (have 10 breakpoints in a file). All in all, there are 32 achievements awaiting to be unlocked, all of which are listed here. Here's what the 6 different badges look like:

The Six Categories of Achievements

Customizing Visual Studio	Don't Try This At Home	Good Housekeeping


Just For Fun	Power Coder	Unleashing Visual Studio

Share Your Flair

Each time you earn a badge, a unique page is created with your profile picture, the badge and a description. You can tweet about achievements you earn and/or share them on Facebook:

Figure 3 - Share A Page

Or, you can show a list of achievements on your blog using the Visual Studio Achievements Widget which is as simple as adding one line of script to your page. After all, those badges look so shiny and nice! Here's an example of the widget on a blog:

Figure 4 - The Visual Studio Achievements Widget On A Blog

Genesis

We have to give props to the blog While True, whose blog post What If Visual Studio Had Achievements inspired us to go build this. That post spawned a reddit post that is the thread which started it all!

Feedback

We're just getting started with Visual Studio Achievements and are hoping to release more in the future. If you have ideas for additional achievements, we'd love to hear about them. Please use the Q&A section of the achievements extension to make suggestions for future achievements. And if you have suggestions, concerns, issues or problems, again, use the Q&A section of the achievements gallery page. Give a read to the FAQ as well as your question may already be answered.

Download it today from the Visual Studio Gallery

Give us your feedback on Visual Studio 11 etc. and receive a gift!

Visual Studio Blog — Wed, 04 Jan 2012 18:00:00 GMT

The Microsoft Visual Studio Design Research Team is looking for participants to give us direct feedback on our development tools, languages and libraries! Opportunities include usability studies of upcoming features, focus groups where we explore new ideas, as well as 1:1 interviews.

What do you get out of it?

When you are selected to participate in one of our research studies, benefits include a combination of the following:

A chance to see and use upcoming tools, features, and language/library enhancements
Interact directly with members of our development teams to discuss your requirements for efficient and effective tools,
Directly influence future design decisions, and
Receive a choice of a Microsoft product from our gratuity list - ranging from Visual Studio Pro thru Xbox games!

We have a brief enrollment form that will ask you a few questions about your company, your job, and the software and languages you actively use. We will contact you as soon as we have a research study that matches your specific background and/or interests.

Enrollment Form

This enrollment should only take 3-5 minutes to complete. For more information about the program feel free to email us at vsdr@microsoft.com. Please note that the Enrollment link originates from Microsoft User Research and is hosted by our survey software provider. Visit http://www.microsoft.com/userresearch/studies.aspx if you have any concerns. Please note that government employees and non-U.S. residents are not eligible for a Microsoft gratuity.

Thanks,
Karl Melder
UX Lead, DevDiv User Experience

Microsoft Windows Simulator Rotation and Resolution Emulation

Zebin Chen — Fri, 04 Nov 2011 10:35:00 GMT

The Windows Simulator is a tool provided in Visual Studio 11 Developer Preview that helps debugging Metro style applications. Its main purpose is to enable debugging when developers want to test how their applications respond to the new metro capabilities without having a device that supports those capabilities. It is implemented as a remote connection session to the same machine, but additionally emulates common hardware functionalities available in new devices, e.g., Rotation (i.e., orientation change), High Resolution and Touch. A general introduction can be found here. This article focuses on Rotation and Resolution emulation.

Rotation and Orientation-Aware Application

Roughly, an orientation-aware application can be coded in two ways (A sample app is available here [1]):

1. It can listen to the Orientation Sensor. As shown in the sample [1], it looks like:

OrientationSensor _sensor = OrientationSensor.GetDefault();

if (_sensor != null) {

 _sensor.ReadingChanged += new TypedEventHandler<OrientationSensor,

 OrientationSensorReadingChangedEventArgs>(ReadingChanged);

2. It can also listen to the display orientation change.

This can be hooked in HTML code through @media rule. Additional customization can be achieved by adding an event handler to Windows.Graphics.Display.DisplayProperties.

The Simulator doesn’t support the emulation of Orientation Sensor, and is only able to trigger a display orientation change. Therefore in the following section, we will concentrate on examples of orientation-aware applications that work with the Simulator.

Orientation-Aware Application: HTML/CSS Binding

Let’s start with an orientation-aware application that has only HTML tag.

1. Start Visual Studio Express. Then create a Blank Application, by clicking “File/New Project…”, “Templates/JavaScript/Blank Application”

2. In the generated project, you will find a file default.html. Make the following modifications to the generated code:

2.1 Add the following code to the end of <head>...</head> code block.

<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />

<meta http-equiv="X-UA-Compatible" content="IE=edge" />

<meta http-equiv="MSThemeCompatible" content="yes" />

<style type="text/css">

 #fullscreen { }

 #fill { }

 #snapped { }

 #deviceportrait { }

 @media screen and (-ms-view-state: full-screen) {

 #fill { display: none; }

 #snapped { display: none; }

 #deviceportrait { display: none; }

 @media screen and (-ms-view-state: fill) {

 #fullscreen { display: none; }

 #snapped { display: none; }

 #deviceportrait { display: none; }

 @media screen and (-ms-view-state: snapped) {

 #fullscreen { display: none; }

 #fill { display: none; }

 #deviceportrait { display: none; }

 @media screen and (-ms-view-state: device-portrait) {

 #fullscreen { display: none; }

 #fill { display: none; }

 #snapped { display: none; }

</style>

2.2 Add the following code to the end of <body>...</body> code block.

<div id="fullscreen" class="win-contentSubtitle">Full Screen</div>

<div id="fill" class="win-contentSubtitle">Fill</div>

<div id="snapped" class="win-contentSubtitle">Snapped</div>

<div id="deviceportrait" class="win-contentSubtitle">Device Portrait</div>

Together, the above code claims that when the metro app is in full-screen landscape mode, the app shows “Full Screen”; when it is in full-screen portrait mode, the app shows “Device Portrait”. (Note: by MSDN definition, “a value of full-screen indicates the device is in landscape orientation and the application’s client area is the same height and width as the device’s height and width.” For a detailed explanation about -ms-view-state media feature, refer to this MSDN article[2]).

3. Now change the debug target from “Local Machine” (the default value) to “Simulator”.

4. F5 to start the debugging.

You should see the app displaying something like “Full Screen”.

5. Click the Simulator “Rotate +90 degrees” button to rotate the Simulator clockwise for 90 degrees.

You should see the app displaying something like “Device Portrait”.

In summary, we have shown a sample of how to write an orientation-aware metro app. Without orientation sensor, it is not straightforward to trigger –ms-view-state event so that one can test his/her metro app. The Simulator comes to the rescue in this case.

Orientation-Aware Application: Binding through Event Handler

Another approach to customize a metro app in response to an orientation change is to explicitly add an event handler. The code is as simple as:

Windows.Graphics.Display.DisplayProperties.OrientationChanged +=

 new DisplayPropertiesEventHandler(DisplayProperties_OrientationChanged);

An interested reader can download the sample application [1]to try the debugging experience with the Simulator. Here are the detailed steps:

1. Download the sample project and unzip the solution to a temp folder.

2. Start Visual Studio Express and open the project OrientationCS.csproj.

3. Now change the debug target from “Local Machine” (the default value) to “Simulator”.

4. Set a breakpoint at MainPage.xaml.cs in the below code (around line 190):

if (DisplayProperties.CurrentOrientation == DisplayOrientations.Portrait

 || DisplayProperties.CurrentOrientation == DisplayOrientations.PortraitFlipped)

5. F5 to debug the app.

6. Click the Simulator “Rotate +90 degrees” button to rotate the Simulator clockwise for 90 degrees. Now you should see the breakpoint hit!

Again, without the Simulator, it would be difficult to debug such application without having an actual device with an orientation sensor.

Resolution

Assume a developer has a computer with “mismatched” video adapter and monitor: the video adapter supports a high resolution while the monitor doesn’t. In such case it would be difficult for the developer to test his metro app in the high resolution. Again, the Simulator helps in this case: It displays common resolutions that are supported by the video adapter, and allows the user to choose each resolution for testing purpose inside the Simulator. For example, in the below screenshot of the Simulator, it shows various resolutions supported by my computer’s video driver. Here I am able to test a metro app with a high resolution of 2560*1440, even though my monitor doesn’t display such high resolution.

I hope that you have enjoyed this post. By now you should have a good understanding about the support for rotation and resolution in the Simulator.

Thanks,

Zebin Chen

Software Development Engineer, Visual Studio

References:

[1] OrientationSensor Sample: http://code.msdn.microsoft.com/windowsapps/OrientationSensor-Sample-99595893

[2] –ms-view-state media feature: http://msdn.microsoft.com/en-us/library/windows/apps/hh465826(v=VS.85).aspx

Debugging Contracts using Windows Simulator

Cathy Sullivan - MSFT — Tue, 01 Nov 2011 18:00:00 GMT

All of you might be pretty busy discovering what Windows 8 has to offer. Today I will introduce you to debugging Contracts, one of the cool features in Windows 8.

It is hard to debug contracts when you are debugging locally because they disappear as soon as the focus is lost. So, as you hit a breakpoint in Visual Studio for your app, the target app would disappear making it difficult to debug your app.

Visual Studio 11 Developer Preview ships with a Windows Simulator. The Simulator helps with debugging contracts as it’s a separate session and the target app does not disappear on switching focus to VS. Simulator is also useful in debugging switching between landscape and portrait modes, targeting various device sizes and resolutions, and emulating touch points. Here is an introductory post about Windows Simulator. You can also refer to this post for more information on testing touch using Simulator.

I will use the JavaScript Share Source Sample App and Share Target Sample App (provided by the Windows Developer Preview Metro style apps samples) for my demonstration.

Using Local Debugging

After downloading and unpacking the sample, open the solution ShareSource.sln in Visual Studio 11 Developer Preview.
Once the solution is loaded, press F5 to start app locally.
When the App is running, you can switch to Visual Studio, stop debugging and close the solution. We don’t need to debug the Source App for our illustration. We just need to have it deployed.
Now open the solution ShareTarget.sln in Visual Studio.
Change the project properties (Right click on the Project in the Solution Explorer and then click Properties) and set the value of Launch Application under Debugging tab to No. This should register the application for debugging. While Visual Studio will not launch the application, it will start debugging the application whenever it is activated.

If you are using C#/VB project, make sure to select the following option under Debug tab.

Open the file target.js and put a breakpoint in the method activatedHandler as shown below:

6. Press F5 to start debugging.

Go to the Start screen and search for Share Source Sample App. As Share Source Sample App becomes active, share some text as shown below:

List of target apps for share contract will appear on the right side, and from the list of available apps select Share Target Sample App.

You will notice that as soon as you hit the breakpoint, target app will disappear making it hard to debug your code.

Using Windows Simulator

Now let's try the same thing using Windows Simulator. Press Stop Debugging in Visual Studio 11 Developer Preview and start debugging again using Simulator.

Once the Simulator is up and running and your Share Target Sample App is active, click on the Windows button in the Simulator to go to the Start screen, and search for Share Source Sample App. As Share Source Sample App becomes active, start sharing with the Share Target Sample App using same steps described earlier.

You will notice that target app is still visible in the Simulator after breakpoint is hit. Continue debugging using F10, and you can still observe your target app in parallel as seen below.

I hope you will find this post useful for debugging contracts.

Thanks,
Ravneet Singh Khalsa
Software Design Engineer, Visual Studio

Visual Studio 2010 SP1 – now available on Microsoft Update

Visual Studio Blog — Tue, 25 Oct 2011 17:10:00 GMT

As of today, Visual Studio 2010 SP1 is now available through Microsoft Update. If you have opted into Microsoft Update and haven’t installed SP1 yet, you will soon have it offered to you. The service pack was initially released in March and includes some often requested feature improvements, fixes that improve reliability as well as the most commonly-reported customer bugs.

For more information, check out the following blog posts and links:

Enjoy!

Jack Unverferth
The Visual Studio Professional Team

An update on Visual Studio performance

Visual Studio Blog — Thu, 20 Oct 2011 21:24:00 GMT

I wanted to take the time to thank everyone who has contributed to our UserVoice performance site by entering areas you would like to see us improve and for voting on those items. To date we have had over 4700 posts and votes showing the passion you all have for Visual Studio and its performance. For those that have downloaded the Visual Studio 11 Developer Preview from the Microsoft \\Build Conference I would like to encourage you to post any performance issues you are seeing with that drop of Visual Studio as well.

As I said in the initial post Visual Studio’s performance continues to be a hot topic and we appreciate the feedback we have received on this site, and through other forums. We are listening to your feedback and continuing to invest in improving performance across a number of areas you all have posted and voted for on this site along with data we are receiving through the instrumentation provided by PerfWatson described below. I wanted to reiterate that our approach to gathering the key areas to improve are twofold and include:

Collecting feedback from you to prioritize our work
Implementing instrumentation in Visual Studio to collect data in cases where the product performs poorly

Collecting Customer Feedback

Please continue to use our single stop for feedback on Visual Studio Performance at our UserVoice site and post items or vote on the performance issues you find are impacting you the most. This feedback has been, and will continue to be, incorporated into our plans as we prioritize our work.

Instrumentation

I want to spend a bit more time encouraging you to make use of Visual Studio PerfWatson, which is included in Visual Studio 11 Developer Preview. PerfWatson, much like regular Watson, enables us to collect data from your machine right when you experience a performance problem. This data allows us to pinpoint right when you experienced a significant pause or delay in the product and we can then debug the exact stack that is causing your Visual Studio instance to experience a performance delay. This blog post describes how we are using the data to identify and fix performance problems. By combining your feedback with this data we continue to work on addressing those issues affecting you the most.

What to look for Next

As we finish our performance work and validate the wins I will be posting some videos of before and after scenarios for you to see. Please look for these posts as we enter the new year. I continue to read the posts, comments, vote totals at the UserVoice site along with PerfWatson reports indicating stacks that are being the most problematic. This dual view of human perception along with instrumented data is invaluable to our understanding of what is impacting you the most, and again I appreciate your passion for helping us make Visual Studio better for you.

Thank you for your support,

Larry Sullivan
Director of Engineering

Roslyn Syntax Visualizers

Visual Studio Blog — Wed, 19 Oct 2011 14:00:00 GMT

Hello everyone! As you may have heard, today we announced the first CTP of the Roslyn project! You can visit the Roslyn MSDN Page to learn more about the project and to download the CTP. You can also read more about Roslyn at the following links -

In this post I will present a brief overview of two samples that are installed as part of the CTP – the Syntax Visualizer Tool Window and the Syntax Debugger Visualizer – and discuss how to install and use these samples. These samples are in essence tools that can simplify inspection and exploration of Roslyn Syntax Trees. You can use these visualizers as debugging aids when you develop your own applications / code issues / code refactorings using the Roslyn APIs.

Getting Started

Lets begin by downloading and installing the CTP from Roslyn CTP Download Page. Once installed, the best place to start is to open Start Menu -> Microsoft Codename Roslyn CTP -> Getting Started. This will launch the the “Getting Started” guide which provides a great overview of what’s included in the CTP as well as links to launch the documents, walkthroughs and samples that are included in the CTP.

To understand the concepts presented in this blog post better, I would strongly recommend reading the Roslyn Project Overview Document. This document provides a great overview of the Roslyn Syntax API including Syntax Trees, Syntax Nodes, Syntax Tokens and Syntax Trivia. This document is installed on your machine when you install the CTP and you can open this document using the link in the “Getting Started” guide.

Next, lets navigate to the Samples section in the “Getting Started” guide by clicking on the link titled ‘Samples’ under the section titled ‘Contents’. Then click on the link titled ‘Roslyn Development Tools’. This should bring you to a section that gives a brief overview of two samples that are the subject of this post -

Lets take a closer look at these samples.

Syntax Visualizer Tool Window

The Syntax Visualizer Tool Window sample is a Visual Studio Extension that enables inspection of 'live' Roslyn Syntax Trees for any C# or VB code file that is open inside the Visual Studio IDE when the Roslyn Language Service is present. The Roslyn Language Service is present whenever you are running or debugging other Roslyn extensions (like code issues and code refactorings). It is also present whenever you debug (F5) or run (Ctrl + F5) the project for the Syntax Visualizer Tool Window sample.

Lets open the Syntax Visualizer Tool Window sample in Visual Studio by clicking on the link with the corresponding title in the “Getting Started” guide. Once the project is open inside Visual Studio, you should find a file named ‘Readme.html’ under the ‘SyntaxVisualizerExtension’ project as shown in the below image. This file contains a brief overview of this sample and also details the steps for installing and running this sample.

Now lets build and run this sample by clicking on Debug –> Start Debugging (F5) or Debug –> Start Without Debugging (Ctrl + F5). This should bring up a new instance of Visual Studio (within which the Roslyn Language Service is present).

In this new Visual Studio instance, click on View –> Other Windows –> Roslyn Syntax Visualizer to bring up the Syntax Visualizer.

This should bring up a tool window that looks like below. Lets dock this tool window at a convenient location inside Visual Studio. I usually dock this window on the left side.

Now in the same Visual Studio instance, create a new project by clicking on File –> New Project. You can create either a VB / C# project. As soon as Visual Studio opens the main code file for this project, you should see the Syntax Tree for this file in the visualizer tool window as shown in the below image. You can open any existing C# / VB file in this Visual Studio instance and the Syntax Tree for the opened file will be displayed in the visualizer tool window. If you have multiple code files open inside Visual Studio, the visualizer will always display the Syntax Tree for the currently active code file (i.e. the code file that has keyboard focus).

As you can see in the above image, the visualizer tool window displays the Syntax Tree at the top and a property grid at the bottom. The property grid displays the properties of the item that is currently selected in the tree, including the .NET ‘Type’ and the ‘Kind’ (SyntaxKind) of the item.

Roslyn Syntax Trees are comprised of three types of items – Syntax Nodes, Syntax Tokens and Syntax Trivia. You can read more about these types in the Roslyn Project Overview Document. Items of each type are represented using a different color. You can click on the button titled ‘Legend’ for a better understanding of this color coding.

Each item in the tree also displays its own ‘Span’. In the above example, the selected item “ModuleKeyword [0..6)” has a Span that is 6 characters wide i.e. [0..6).

There are a couple of different ways in which you can navigate the tree -

You can navigate the tree by expanding / clicking on items in the tree. If you click on an item in the tree, the visualizer will automatically select the text corresponding to this item’s Span in the code editor.
You can also navigate the tree by clicking on / selecting text in the code editor. In the above example, if you select the line containing “Module Module1” in the code editor, the visualizer will automatically navigate to the corresponding “ModuleStatement [0..14)” item in the tree. In essence, the visualizer will try to find and highlight the item in the tree whose span best matches the span of the text that you select.

Next, lets see what happens when we modify the code in the active code file. In the above example, lets type the statement “Console.WriteLine()” inside the “Sub Main()" block. As you type, notice that the visualizer refreshes the tree to match the most current version of the typed code.

Pause typing once you have typed “Console.” Notice that the tree has some items colored in pink. This is because at this point, there are errors (also referred to as ‘Diagnostics’) in the typed code. These errors are attached to Syntax Nodes / Syntax Tokens / Syntax Trivia in the Syntax Tree and the visualizer shows you which items have errors attached to them by coloring them specially. You can inspect the errors that are present on any item colored pink by hovering over the item with your mouse. Note that the visualizer will only display syntactic errors (i.e. errors related to the syntax of the typed code) – it will not display any semantic errors.

In Visual Studio Premium and Visual Studio Ultimate, you can also right click on any item in the visualizer tool window and click on Directed Syntax Graph. This will display a graphical representation of the sub-tree rooted at the selected item. This feature is not available in Visual Studio Professional.

Lets try this for the “SubBlock [22..47)” item in the above example. This should display a Syntax Graph that looks as follows.

As you can see the Syntax Graph also displays a legend for the coloring scheme it uses. You can hover over individual items in the Syntax Graph with the mouse to view the properties corresponding to that item.

You can view Syntax Graphs for different items in the tree repeatedly and the graphs will always be displayed in the same window inside Visual Studio. You can dock this window at a convenient location inside Visual Studio so that you don’t have to switch between tabs to view a new Syntax Graph. I usually dock this window at the bottom (below my code editor windows).

Below is the docking layout that I normally use for the visualizer tool window and the Syntax Graph window.

You can close the visualizer tool window at any time and once closed it should cease to have any impact. You can also disable / uninstall the visualizer extension completely using Tools –> Extension Manager in Visual Studio.

With that we come to the end of the overview for the Syntax Visualizer Tool Window sample.

Syntax Debugger Visualizer

Next, lets take a look at the Syntax Debugger Visualizer sample. This sample is a tool that can be used within a Visual Studio debug session to visualize Roslyn Syntax Trees, Syntax Nodes, Syntax Tokens and Syntax Trivia.

Open the Syntax Debugger Visualizer sample in Visual Studio by clicking on the link with the corresponding title in the “Getting Started” guide. Once the project is open inside Visual Studio, you should find a file named ‘Readme.html’ under the ‘SyntaxDebuggerVisualizer’ project as shown in the below image. This file contains a brief overview of this sample and also details the steps for installing and running this sample.

The ‘SyntaxDebuggerVisualizer’ project itself is just a library, and cannot be run. Lets build this project by clicking on Build –> Build Solution in Visual Studio. Next, lets navigate to the bin directory of this project and copy the files present in this directory to the ...\Documents\Visual Studio 2010\Visualizers directory. You may need to create the ...\Documents\Visual Studio 2010\Visualizers directory in case it doesn’t exist already on your computer.

Once copied, the debugger visualizer is ready for use within Visual Studio. Close and reopen Visual Studio to make sure that the debugger visualizer is recognized.

Lets write a small test program to test the debugger visualizer. In the new instance of Visual Studio that you just opened, create a new Roslyn Console Application using the File –> New Project dialog.

In the “Main()” function of this Roslyn Console Application, paste the following code -

var tree = Roslyn.Compilers.CSharp.SyntaxTree.ParseCompilationUnit(@"class c1 { }");

var token = tree.Root.DescendentTokens().First();

Console.WriteLine(token.Kind);

The above code uses the Roslyn API to create a Syntax Tree, selects a Syntax Token from this tree and prints the ‘Kind’ of this Syntax Token on the console. Lets put a breakpoint on the “Console.WriteLine(token.Kind);” line above and run the program under the debugger by clicking on Debug –> Start Debugging (F5).

Once the execution breaks at the breakpoint, lets bring up Visual Studio’s Autos window. Notice the magnifying glass icons that appear next to the two variables in the Autos window. The presence of this magnifying glass icon indicates that the debugger visualizer was correctly installed and that it is available for use.

In fact, once the debugger visualizer is installed, the above magnifying glass icon should appear in debugger windows next to any object with type -

Roslyn.Compilers.Common.CommonSyntaxTree
Roslyn.Compilers.Common.CommonSyntaxNodeOrToken
Roslyn.Compilers.Common.CommonSyntaxNode
Roslyn.Compilers.Common.CommonSyntaxToken
Roslyn.Compilers.Common.CommonSyntaxTrivia
Roslyn.Compilers.CSharp.SyntaxTree
Roslyn.Compilers.CSharp.SyntaxNodeOrToken
Roslyn.Compilers.CSharp.SyntaxNode
Roslyn.Compilers.CSharp.SyntaxToken
Roslyn.Compilers.CSharp.SyntaxTrivia
Roslyn.Compilers.VisualBasic.SyntaxTree
Roslyn.Compilers.VisualBasic.SyntaxNodeOrToken
Roslyn.Compilers.VisualBasic.SyntaxNode
Roslyn.Compilers.VisualBasic.SyntaxToken
Roslyn.Compilers.VisualBasic.SyntaxTrivia

Lets click on the magnifying glass that appears next to the variable “token” in the Auto’s window above. This should bring up the following debugger visualizer window. The Syntax Token that you selected in the Autos window is highlighted in the tree and the text corresponding to the Span of this Syntax Token is also highlighted in the text box.

The visualizer displays the Syntax Tree at the top and a property grid at the bottom and the operation of these controls is essentially the same as in the case of the Syntax Visualizer Tool Window sample that we discussed earlier in this post. The rich Visual Studio code editor in the Syntax Visualizer Tool Window is replaced with a read-only text box in the Syntax Debugger Visualizer. However, you can still navigate the tree by either clicking on / expanding items in the tree or by clicking on / selecting text in the text box.

For example, lets select the closing brace “}” in the text box using the mouse – this will automatically select the corresponding item in the tree as shown in the below image.

Notice also that the Line, Column and Position info corresponding to the currently selected text in the text box are displayed at the top right portion of the visualizer window.

Note: The debugger visualizer does not support visualizing the following types of objects. It will display an error message if it encounters an object that it cannot visualize correctly.

Syntax Nodes / Syntax Tokens / Syntax Trivia from a Syntax Tree that was parsed using non-default Parse Options.
Syntax Nodes / Syntax Tokens / Syntax Trivia generated using Roslyn Syntax Factory Methods (such as Syntax.ParseExpression(), Syntax.ParseStatement(), Syntax.CompilationUnit() etc.).

Note: There is a known bug in the implementation of the Syntax Debugger Visualizer sample. Please take a look at this Roslyn Forum Post (that contains a list of known issues for the Roslyn CTP) for a description of this bug and how you can fix this.

Feedback

I hope you had a fun time learning about the two Syntax Visualizers. Do try them out and use them as you explore the Roslyn APIs and develop new code issues / code refactorings!

We are very excited to get an early preview of the Roslyn technology in your hands and would love to hear your feedback, ideas and suggestions about the CTP and also about the visualizer tools described in this post. Please use the CTP to build rich code tools and extensions so that you can learn more about the APIs and provide feedback.

Please note that this is a technology preview and there are known limitations and bugs. The primary goal of this CTP is to give you an early preview of the Roslyn APIs and gather feedback. While the shape of the public API surface is complete, only a subset of the C# and Visual Basic languages have been implemented end-to-end in the CTP. You can find a complete list of known issues and non-implemented language features on this Roslyn Forum Post.

Please use the Roslyn Forum to ask questions and provide feedback and Microsoft Connect to log bugs and suggestions.

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

Introducing the Microsoft “Roslyn” CTP

Visual Studio Blog — Wed, 19 Oct 2011 12:30:00 GMT

Today we are releasing the first Community Technology Preview of the Roslyn Project!

What is Roslyn?

In the past, our compilers have acted as black boxes – you put source text in and out the other end comes an assembly. All of that rich knowledge and information that the compiler produces is thrown away and unavailable for anyone else to use.

As Soma mentions in his blog, a part of the Visual Studio languages team is working on a project called Roslyn with a goal to rewrite the C# and VB compilers and language services in managed code. With a clean, modern, managed codebase our team can be more productive, innovate faster, and deliver more features sooner and with better quality.

More importantly, we are opening up the C# and Visual Basic compilers and exposing all that rich information and code analysis to be available for your use. We expose a public API surface and provide extension points in the C# and VB language services.

This opens up new opportunities for VS extenders to write powerful refactorings and language analysis tools, as well as allow anyone to incorporate our parsers, semantic engines, code generators and scripting in their own applications.

Download the October 2011 CTP

The CTP and supporting materials can be downloaded from:

http://msdn.com/roslyn

The main goal of this early preview is to gather feedback on the API design and to introduce the C# Interactive window (also known as REPL, or Read-Eval-Print-Loop).

This first CTP is intended for preview-use only and does not allow redistribution of the Roslyn components or allow use in a production environment.

The CTP installs on Visual Studio 2010 SP1. It also requires the Visual Studio 2010 SP1 SDK.

Getting Started

After the installation succeeds, the best place to start is to open Start Menu -> Microsoft Codename Roslyn CTP -> Getting Started.

To get started, the “Roslyn Project Overview” document gives a look at the compiler API – how to work with syntax and semantics of your program. Several walkthrough documents are also included to provide a deep dive into various aspects of the Roslyn APIs.

The CTP ships with quite a few samples for Visual Studio Extensions, compiler API, code issues, refactorings and so on. Most of the samples are provided for both C# and Visual Basic. You can open the sample source code from the Getting Started page.

We also install several new project templates available in the New Project dialog:

These templates will help you to get started on a new Visual Studio extension that uses Roslyn.

Reference Assemblies

The Roslyn assemblies are also installed in the GAC. Switch to the Full Profile (instead of the Client Profile) to be able to also reference the Services assemblies (which contain the IDE support).

C# Interactive window

You can invoke the C# Interactive window from View -> Other Windows -> C# Interactive Window. The Interactive window is powered by the new C# language service. The architecture of Roslyn is flexible enough to allow many of the IDE features such as IntelliSense and refactorings to work the same in a normal editor and in the Interactive window.

At this time, the Interactive window is only available for C#. We’re working hard on providing the VB Interactive at a future time.

C# Script File (.csx) Editing Support

The CTP introduces a concept of a C# Script File. You can create a .csx file through File -> New File (or also use any other editor such as notepad):

You can run scripts using the new rcsi.exe, which installs into %ProgramFiles(x86)%\Microsoft Codename Roslyn CTP\Binaries\rcsi.exe. You can add rcsi.exe to the path and then type rcsi <scriptfilename>.csx.

You can also copy chunks of code from a script file and send them to the C# Interactive Window (using the right-click context menu or a keyboard shortcut).

The editor for the script files is also powered by the new language services. Hence it is important to keep in mind that .csx scripts will only support the part of the language already implemented in the Roslyn compilers. For more details, see the "Introduction to Scripting" walkthrough.

Quick sample of the Roslyn API

Here’s a sample of compiling and executing a small program using the Roslyn API.

using Roslyn.Compilers;
using Roslyn.Compilers.CSharp;

...

var text = @"class Calc { public static object Eval() { return 42; } }";
 
var tree = SyntaxTree.ParseCompilationUnit(text);
var compilation = Compilation.Create(
    "calc.dll",
    options: new CompilationOptions(assemblyKind: AssemblyKind.DynamicallyLinkedLibrary),
    syntaxTrees: new[] { tree },
    references: new[] { new AssemblyFileReference(typeof(object).Assembly.Location) });
 
Assembly compiledAssembly;
using (var stream = new MemoryStream())
{
    EmitResult compileResult = compilation.Emit(stream);
    compiledAssembly = Assembly.Load(stream.GetBuffer());
}
 
Type calc = compiledAssembly.GetType("Calc");
MethodInfo eval = calc.GetMethod("Eval");
string answer = eval.Invoke(null, null).ToString();
 
Assert.AreEqual("42", answer);

Note: At this stage, only a subset of the language features has been implemented in the current CTP. We’re moving forward at a fast pace, but features such as Linq query expressions, attributes, events, dynamic, async are not yet implemented. To see a full list of non-implemented language features, see the Roslyn forums.

Although not all the language features are supported, the shape of the public API is mostly complete, so we encourage you to write extensions and tools against the Syntax, Symbols, and Flow and Region Analysis APIs.

We’re very excited to get an early preview of this technology in your hands and we welcome your feedback, ideas and suggestions. Use the forums to ask questions and provide feedback, Microsoft Connect to log bugs and suggestions, and use the #RoslynCTP hashtag on Twitter.

Thanks,

Kirill Osenkov

QA (Roslyn Services Team)

Blog: http://blogs.msdn.com/b/kirillosenkov

Twitter: @KirillOsenkov

Visual Studio 11 Developer Preview: Search Everywhere

Visual Studio Blog — Tue, 11 Oct 2011 17:43:00 GMT

During usability studies on previous versions of Visual Studio, we found many users were spending quite a lot of time browsing long lists of data from files in Solution Explorer to controls in the Toolbox, errors or warnings in the Error list, menus, bugs, etc. More often than not you know what you want but finding it in the list can be tedious. Visual Studio 11 Developer Preview aims at increasing productivity by reducing the amount of time it takes to traverse through these lists by adding search to a number of common windows.

Video: VS11 Developer Preview Search Everywhere

Search in Solution Explorer

Location: Between Solution Explorer toolbar and Solution

Keyboard Shortcut: Ctrl + ;

Navigating through huge projects or solutions to find the file, class, or member you want is extremely easy with search in Solution Explorer. Pressing Ctrl+; will place focus in the Solution Explorer search box and allow you to filter down the tree view. You don’t need to remember the entire name of a file or even how it starts, because this search is a ‘contains’ search. So as long as you know any part of the substring, type it in (no need to press ‘enter’ – Search starts the moment you start typing to give you instant results) and all results that ‘contain’ the keyword will show.

Pascal Case search is also enabled in Solution Explorer. Pascal Casing is when the first letter of every word in the name of a folder or file is capitalized. By typing in just the capitalized letters you can search for the class or member. For example, search “BJG” for the class name BlackJackGame. NOTE: The Developer Preview doesn’t support Pascal Casing on projects, files, or folders yet – only language nodes are searchable through Pascal Casing. We are looking to add full support later this release

Search in Error list

Location: Top right corner of Error List window

Finding the right error in the Error List can be challenging at times, so for VS11 we’ve added a search box to the Error List to help you find the right error, warning, or message. The search will look through all columns, not just the error description, thus allowing you to easily scope the results through a file or project name.

As a complement to search, the Error List now has a filtering button in the top-left which allows you to scope the results in the list to the errors, warnings, and messages in the Open Documents, Current Project, Current Document. When you switch files, the filter is applied to that file allowing you to zero in on just the files you are interested in.

Location: Top left corner of Error List window

Search in Other Windows

We’ve talked about two of our favorite new search additions, but you’ll find that search has been added to a number of places throughout VS, including:

Add Reference Dialog
Team Explorer – includes search filters for narrowing down the bug list.
Quick Find
Intellitrace Summary Page
Parallel Watch Window
C++ Graphics Event List
And More

Quick Launch

Location: Top right corner of IDE

Keyboard Shortcut: Ctrl + ` [back quote]

Probably the most useful new search box is the one in the upper right corner of VS: Quick Launch. The keyboard shortcut to place focus in Quick Launch is Ctrl + ` [back quote]. (Back Quote shares the key with ~ on US keyboards, and is to the left of the ‘1’ button). NOTE: You can change the keyboard shortcut via Tools->Options->Environment->Keyboard and searching for “Window.QuickLaunch”.

Quick Launch will search over commands, options, and open documents within VS. To create a new project, just type “new project” and press ENTER. Too add a class, just type “Add Class” and press ENTER. Quick Launch makes it very easy to execute actions inside VS. Additionally, the keyboard shortcut for the commands will be listed next to the result, allowing you to quickly memorize keyboard shortcuts.

Quick Launch will also maintain a most recently used (MRU) list of your frequently executed commands allowing common results to show up first in your search results. While Quick Launch ships with these out-of-the-box categories, we support the ability of 3^rd parties to add search categories as well.

For detailed coverage on Quick Launch functionality check out Zain Naboulsi’s blog here.

Feedback

We’d love to hear from you! All customer feedback is reviewed and constantly used to improve the product, so please let us know what you think about these new features in Visual Studio 11 Developer Preview.

If you encounter a bug or find something working different than you expect, please file a bug by logging onto Microsoft Connect. If you have a suggestion, please add it to User Voice and also vote on other suggestions so we know what is important to you.

Thanks! RadhikaTadinada Program Manager (Visual Studio Platform)

Improving developer productivity with Visual Studio 11 Developer Preview

Visual Studio Blog — Fri, 07 Oct 2011 00:06:00 GMT

One of the things we’ve been doing in Visual Studio 11 Developer Preview (VS11) is focusing on ways to increase developer productivity and improve the performance of VS. Through careful observation of developers using Visual Studio and through talking to developers, we learned that one of the ways we could improve developer productivity would be by reducing the number of things that developers have to pay attention to and manage. Fewer tool windows, fewer toolbars, fewer irrelevant documents in the IDE would provide developers with more time to concentrate on their own code.

We’ve taken this on board and have made a few changes to the way things work in Visual Studio that we think will result in some big productivity gains. Let’s start by taking a look at how we reduce the number of documents that a developer has to manage.

Reducing Document Overload

Developers often end up with additional documents open in the IDE as a side effect of performing some other activity such as stepping through code in the debugger, triaging search results, or foraging through files in a solution. For example, imagine I am trying to track down a bug that shows up whenever I make a call to some method. I place a breakpoint on that method then step into every method that it calls, and the methods that they call, until I finally reach the buggy code. It’s not uncommon in these situations to step through a number of different methods until finally reaching the buggy code. The following call stack shows a contrived example. I placed a breakpoint in Main and stepped through a number of intermediate methods until eventually landing on the buggy method.

Each step into an intermediate method resulted in another file being opened up in the IDE. As it turns out, these files aren’t really important to helping me debug the problem but they sit there, taking up space, and forcing me to work around them. Worse still, if I get interrupted (and who doesn’t?), when I return to my task I need to read through the files to remind myself that these files aren’t really important. All wasted effort and time.

Enter the ‘Preview Tab’. In VS11, the preview tab is a special tab that we use to display the content of files that aren’t currently open in the IDE. Each time the user takes an action that would cause a new file to be opened, we open that file up in the preview tab instead. There is only one preview tab, so we refresh the content of the preview tab on each new file that gets opened. So in the above scenario, when I stepped through the files containing IntermediateMethod1, IntermediateMethod2 and IntermediateMethod3, these files were opened in the preview tab, instead of opening up in their own dedicated files. And when we step into the BuggyMethod, that too is opened in the same preview tab.

If you’re already incredibly excited at the thought of previewing files and want to try it out all for yourself, download the Microsoft Visual Studio 11 Developer Preview from here: http://www.microsoft.com/download/en/details.aspx?id=27543). This build has the preview tab turned on by default. You’ll also be able to use the preview tab if you have the Windows 8 Developer Preview installed, but you’ll need to make a couple of changes to the registry to use the preview tab with C++ and VB files.

If you have the Windows 8 Developer Preview installed, there are a couple of things you’ll need to do if you want to experiment with previewing C++ and VB files from the Solution Explorer. Add the following registry keys to enable previewing VB and C++ files from the Solution Explorer:

// Microsoft Visual Basic Editor

[HKEY_CURRENT_USER\Software\Microsoft\VSWinExpress\11.0_Config\Editors\{2C015C70-C72C-11D0-88C3-00A0C9110049}]

"CommonPhysicalViewAttributes"=dword:00000002

// C++ Source Code editor

[HKEY_CURRENT_USER\Software\Microsoft\VSWinExpress\11.0_Config\Editors\{D0E1A5C6-B359-4e41-9B60-3365922C2A22}]

"CommonPhysicalViewAttributes"=dword:00000002

The end result is that instead of five files being opened in the IDE, we only have one file (the file containing the Main definition) and one file in the preview tab. For example:

The tab on the right hand side (containing the file BuggyClass.cs) is the preview tab. We place it over on the right hand side, away from the other regular tabs to indicate that it is a different kind of tab.

When a file is displayed in the preview tab, you can read the content in the file, scroll through it and copy content from the file to paste elsewhere. What if you decide that you want to keep the file around to do some work on it though? How do you prevent the file disappearing as the result of some other action that causes the preview tab to refresh with new content?

There are a couple of ways to open the content in the preview tab into a regular tab.

Just start editing the content. As soon as you make any kind of edit to the file in the preview tab we’ll open that file in a regular tab automatically. No action is required on your part, just start editing the file like you normally would. We don’t want to have to force you to explicitly indicate that you want to keep the file around. We want to allow you to get on with your work so we’ll open it for you as soon as you start editing the file.
Click on the ‘Open’ button. The preview tab has a button in between the file name and the close button. It’s highlighted in red below. Click on this button to open the file in a regular, persistent tab. A new regular tab will be created showing the content of the file and the preview tab will close.

We don’t just use the preview tab while debugging. There are other scenarios that can result in files being opened as a side effect. In each of these scenarios we make use of the preview tab.

Scenario	How the preview tab is used
Goto Definition	Each time the user performs a goto definition, we’ll show the definition in the preview tab unless the file containing the definition is already open in the IDE
Find results	After performing a Find in Files command, selecting any of the results in the find results tool window will show that result in the preview tab, unless it is already open in the IDE. Double clicking will continue to open the result in a regular tab, just as it has always done.
Solution Explorer	Selecting a file in the Solution Explorer will open that file in the preview tab unless it is already open in the IDE. Double clicking will continue to open the the file in a regular tab, just as it has always done.
Search and relationship pivots in Solution Explorer (call hierarchy, base/derived types, find all references)	The Solution Explorer has new functionality in it that supports extensive code navigation scenarios. In each of these scenarios, if the user clicks on a browsable node in the Solution Explorer we’ll show the file containing that node in the preview tab (unless it’s already open).

This opens up the some interesting new experiences. For example, I can use the arrow keys to arrow up and down a list of results in the find results tool window to preview each result. So I can preview the full context of the search result instead of the single line of text that the find results tool window shows me. Since I don’t have to worry about tidying up opened files after previewing the list of results, I can quickly scan through the list of results to find the result I was looking for. Once I find that result, I can just hit the ‘Enter’ key or double click the result to open it as a normal tab (or click on the Open button on the preview tab as described above).

The same is true for the Solution Explorer. Now that we have integrated many more browsing experiences into the Solution Explorer (through the search capabilities and the ability to explore different relationships such as called by, derived from etc) it’s important to enable those experiences in such a way that the user doesn’t have to pay the tax of cleaning up behind them after they have explored through their code. So if you select a file or indeed any other object contained within a file from the Solution Explorer, we’ll show that file inside the preview tab (unless it is already open). That way you can navigate ‘without remorse’. If you don’t want to preview a file (say you just want to select a file so that you can change its name or you want to drag and drop the file somewhere, you can hold down the ‘Alt’ key when single clicking the file to prevent the preview from showing up).

We think that the preview tab will open up a new way of working with files. We’ve tried to implement it such that it doesn’t get in your way so that we don’t force you to change your habits. Our goal is that over time it will play a larger and larger role in the way that you search and work with files.

We’d really love to hear your feedback so please send comments our way.

Thanks!

Steven Clarke

User Experience Researcher (Visual Studio)

Visual Studio 11 Developer Preview Survey

Lisa.Feigenbaum — Tue, 04 Oct 2011 04:23:05 GMT

Have you had a chance to play around with the Visual Studio 11 Developer Preview? If so, we’d like to hear your early impressions, particularly around performance, reliability, and quality. Let us know what you think by taking the Visual Studio 11 Developer Preview survey.

Thanks!
Doug Turnure – Visual Studio Program Manager

Private Extension Galleries for the Enterprise

Visual Studio Blog — Mon, 03 Oct 2011 08:20:00 GMT

In Visual Studio 2010, we introduced a feature called the Extension Manager – a new dialog that connects to the Microsoft Visual Studio Gallery to help a customer easily select and install extensions to Visual Studio from right inside the IDE.

Since then, enterprise customers have frequently asked us to provide a way for Visual Studio to connect to a customer-managed website that contains a private collection of Visual Studio extensions. Today I’m excited to announce a new feature available in the Developer Preview version of VS that does just that, and offers you the same smooth, simple download, install, and update experience that you’ve seen when connected to the public Visual Studio Gallery.

Configuring a private gallery

In the Extension Manager panel of the Tools/Options page, you can now add a URL to the Extension Repositories list that points to the server where your private gallery lives. Visual Studio expects to find an atom feed at this endpoint that describes the extensions available on your gallery.

Using your gallery

The next time you open the Extension Manager Online panel, you’ll see your gallery listed after the two public ones (Visual Studio Gallery and Samples Gallery).

Install looks exactly like it does for the public galleries:

Creating the gallery

On a web server, or on your local or remote file system, create a root directory for your gallery, and add sub-directories for each category in your collection. (In the illustration below, there are two categories: Project X and Project W.)

Place each VSIX file in the folder that corresponds to its category. Then it’s time to create the atom feed.

For this preview version, you’ll create the feed by hand. We’ll make some tools available to automate that process soon. Here is a sample feed, with the element values you’ll need to edit highlighted:

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title type="text"></title>
<id>uuid:874a62b3-c36c-4443-aeb9-498e4c6e589d;id=1</id>
<updated>2011-09-02T01:58:50Z</updated>
<entry>
    <id>MessageInspector.Acme Corp..6b64a54c-93b9-4f0c-a962-71ba1c23c1d8</id>
    <title type="text">MessageInspector</title>
    <summary type="text">Visualizes message exchanges for Project W</summary>
    <published>2011-09-01T18:51:00-07:00</published>
    <updated>2011-09-01T18:57:18-07:00</updated>
    <author>
      <name>Acme Corp.</name>
    </author>
    <category term="ProjectW Tools" />
    <content type="application/octet-stream" src="ProjectW Tools/MessageInspector.vsix" />
    <Vsix xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/developer/vsx-syndication-schema/2010">
      <Id>MessageInspector.Acme Corp..6b64a54c-93b9-4f0c-a962-71ba1c23c1d8</Id>
      <Version>1.0</Version>
      <References />
    </Vsix>
</entry>
<entry>
    <id>DataWarehousingTools.Acme Corp..496be56f-595e-4a50-b02f-5d3da630b7b6</id>
    <title type="text">DataWarehousingTools</title>
    <summary type="text">Data warehousing tools for Project X. (Internal use only.)</summary>
    <published>2011-09-01T18:51:28-07:00</published>
    <updated>2011-09-01T18:57:27-07:00</updated>
    <author>
      <name>Acme Corp.</name>
    </author>
    <category term="ProjectX Tools" />
    <content type="application/octet-stream" src="ProjectX Tools/DataWarehousingTools.vsix" />
    <Vsix xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/developer/vsx-syndication-schema/2010">
      <Id>DataWarehousingTools.Acme Corp..496be56f-595e-4a50-b02f-5d3da630b7b6</Id>
      <Version>1.0</Version>
      <References />
    </Vsix>
</entry>
</feed>

Values highlighted in yellow are taken right from the VSIX Manifest. Those highlighted in green describe how they appear in your gallery:

The term= attribute contains the category name as it will appear in Extension Manager.
The src= attribute contains the path to the VSIX file from the gallery root.

Updating

To publish an update, all you need to do is replace the old VSIX file with the new one, and put the Version value from the new VSIX manifest in the corresponding <Version> element in the feed.

<Id>DataWarehousingTools.Acme Corp..496be56f-595e-4a50-b02f-5d3da630b7b6</Id> <Version>1.1</Version>

Then when your users open Extension Manager they’ll see the new version in the Update panel.

I’ll be blogging about tools to automate the feed generation as soon as we can make them available. In the meantime, try out the feature in the Visual Studio 11 Developer Preview and let us know what you think!

Gary Horen
Program Manager
Visual Studio Platform

Microsoft Windows Simulator Touch Emulation

Visual Studio Blog — Fri, 30 Sep 2011 08:05:00 GMT

The Windows Simulator is a tool provided in Visual Studio 11 Developer Preview that enables debugging Metro style applications in scenarios requiring hardware support such as rotation and touch. For a quick introduction to the Windows Simulator, see this blog entry. This article will introduce you to Touch Emulation in the Windows Simulator.

Touch Emulation in the Simulator enables developers to test and debug how an application reacts to different touch gestures. The Simulator does all the hard work of converting mouse events into touch events received by the running application. This is especially useful for developers who are creating Metro style applications that are touch-enabled but do not have a touch monitor to test those applications.

To demonstrate Touch Emulation inside the Windows Simulator, we will use the Touch Events Sample provided by the Windows Developer Preview Metro style apps samples. After downloading and unpacking the sample, open the solution TouchEvents.sln in Visual Studio 11 Developer Preview, then Debug the sample targeting the Windows Simulator:

The sample will run inside the Windows Simulator and will look something like this:

This sample code recognizes touch events in the right rectangle and displays the information about those events in the left rectangle. Using the Windows Simulator Touch Controls found on the Simulator palette, we can switch between Mouse mode and Touch mode:

When in Touch mode, the Windows Simulator shows a special mouse pointer indicating that it is in Touch Emulation mode. The Simulator will convert mouse clicks into touch events, and the application receives touch events exactly as it would if they were generated by a physical touch device.

The Windows Simulator can also simulate two finger gestures, such as the Pinch/Zoom gesture and the Rotate gesture. When using the two finger gestures, the Windows Simulator will display two contact points.

In Pinch/Zoom mode, use the mouse wheel to set the two contact points closer or farther apart from each other. If you click the left mouse button and rotate the wheel simultaneously, the Windows Simulator will send touch events to the target application as if the user was performing a Pinch/Zoom gesture on a physical touch device. Similarly, in Rotate mode you can use the wheel to rotate the two contact points relative to each other.

The Windows Simulator allows emulating the following touch gestures:

Tap (single contact)
Hold (single contact)
Double Tap (single contact)
Pan/Swipe (single contact)
Flick/Inertia (single contact)
Pinch/Zoom (2 contact points)
Rotate (2 contact points)

We encourage you to use the Touch Emulation features in the Windows Simulator to develop your Windows 8 applications. These features allow you to test and debug your applications to ensure they work correctly for touch - without having a physical touch device.

To learn more about Touch input in Metro style applications, see the following articles:

Responding to Touch Input
Touch Input Quickstart

Thanks,
Mynor Ivan Muralles
Software Design Engineer, Visual Studio

First look at Windows Simulator

Visual Studio Blog — Thu, 29 Sep 2011 08:45:00 GMT

Many friends of mine have been asking me what my team is working on these days. I finally have an opportunity to share with all of you the really cool stuff we’ve been working on for the past many months.

My team built the Windows Simulator enabling users to debug Metro Style apps for Windows 8 in a Windows environment.

There are three primary ways to debug a Metro Style app.

Local Machine
Remote Machine
Simulator

Primary Usage Scenarios for Windows Simulator

There are certain features and traits in Metro style applications that helps them stand out compared to classic windows applications. For a better understanding of Metro Style applications, I strongly recommend viewing the BUILD session by Jensen Harris on 8 traits of great Metro style apps before you start writing any Metro style applications.

The Windows Simulator is really handy when you need to verify how Metro applications measure against these traits. I will introduce them here briefly and later we will have a detailed blog post on each of them.

Touch Emulation
Rotation
Different target screen resolutions
Contracts

Under the hood

Under the hood the Windows Simulator is a Remote Desktop Session into your local machine.

Developers need to be careful while modifying the state of the operating system in the Simulator because any changes in the Simulator will be reflected on the local machine itself. Multiple instances of Visual Studio and Expression Blend share the same instance of the Windows Simulator.

Using Simulator to debug Metro style applications in Visual Studio

To debug an Metro style application using Windows Simulator, Open the application project in Visual Studio and choose Simulator from the debugging options in the Visual Studio toolbar.

Or you can enable Simulator from the Debugging tab of Project Property Pages.

After selecting Simulator to debug the application, simply press F5 or start debugging from the tool bar to launch a Metro style application in the Windows Simulator.

Here is a screenshot of a JavaScript Grid Application running in the Simulator.

To stop debugging choose "Stop Debugging" from the Debug menu of Visual Studio.

Using the Simulator from Expression Blend

Open the project in Expression Blend and then switch to the Platform panel and choose the Simulator as the Deploy target.

Then press F5 to launch application in Windows Simulator.

Touch Emulation

This feature is very useful to test Touch responsiveness for the application on developer machines that do not have touch devices. The Simulator supports single finger touch, tap and hold, pinch and zoom, and rotation. The touch controls are available in the Simulator Palette.

To switch out of touch emulation mode and back into mouse mode, select the mouse pointer. To learn more about Touch Emulation, see this blog entry.

Rotation

Metro style applications should support Landscape and Portrait modes. Visual Studio templates are pre-configured for default behavior for landscape and portrait modes.

Without using an actual tablet device it is not easy to test the application in Portrait and Landscape mode. The Simulator is your friend here.

It is very easy to test the Landscape and Portrait modes using the rotation controls on the Simulator Palette.

Multiple screen Resolutions

Windows 8 can run on PCs of different screen sizes and Resolutions. Metro Style applications should adjust to accommodate various screen sizes and resolutions. Using The Simulator it is very easy to test applications for different screen resolutions. You can use the "Change Resolution" button on the Palette to choose a resolution. The availability of resolutions in the Palette depends upon the supported resolutions of your video card.

Contracts

Almost all the contracts in Metro applications disappear once they lose focus or hit a breakpoint in debugger. It is not possible to debug contracts on your Local Machine without the Simulator. The Simulator is running a different desktop session, so when a breakpoint is hit in the debugger it does not result in a loss of focus in the simulator session.

I hope that you will find Simulator handy in time of need :), please post comments if you have any questions or feedback.

To learn more about developing Metro applications for Windows 8 I highly recommend following //BUILD presentations.

8 traits of great Metro style apps
Platform for Metro style apps
Tools for building Metro style apps

Thanks,
Navneet Gupta
Software Design Engineer, Visual Studio

Visual Studio 11 Developer Preview: Quick Launch

Visual Studio Blog — Tue, 27 Sep 2011 20:16:00 GMT

In the past, finding things deep in the IDE has been a challenge. Visual Studio 11 Developer Preview introduces search abilities at almost every level of the product. Perhaps the biggest change is the introduction of Quick Launch which specifically addresses how to dig inside Visual Studio to find features you need. Let’s take a look.

Shortcut: CTRL + ` [back quote]

Versions: Visual Studio 11 Developer Preview

Quick Launch: Basic Use

You can find Quick Launch in the upper right corner of the IDE:

The most basic scenario for using Quick Launch is finding an item that you have forgotten (or don’t know) the location of. Let’s say you are interested in something deep in the menu system like viewing your white space. You know what it’s called but can’t remember where it is at. Just press CTRL + ` [back quote] and enter the word white:

All searches are contains operations so the results will show anything that has the word white anywhere in it. The results are grouped into categories and you simply either select the item from the list using your keyboard, mouse or, if there is a keyboard shortcut listed, take advantage of the shortcut. In this case, you could press CTRL+R, CTRL+W to show the white space and then go on with your work.

Finally

I absolutely love this feature! My passion is around helping people be more productive in the IDE and I think Quick Launch is probably one of the biggest steps forward for discovery of VS features that I have ever seen. I’ve been using it for several weeks and am at the point now where I can’t imagine not having it. I hope you enjoy it as much as I do.

Thanks,
Zain Naboulsi
Senior Developer Evangelist (Blog)

Visual Studio 11 Developer Preview: Find & Replace

Visual Studio Blog — Thu, 22 Sep 2011 09:25:00 GMT

In Visual Studio 11 Developer Preview we’ve streamlined and modernized our vast array of Find experiences. Find and Replace is now a lightweight control within documents, delivering incremental search results as you type. The Find and Replace in Files dialog has been simplified while at the same time gaining additional functionality such as Find Next and Find Previous. Both Find experiences now let you use .NET Regular Expressions to perform complex search and replace operations, even across multiple lines.

The new Find and Replace Control

The new Find control sits at the top of the document as a search box. Ctrl + F now brings up this control, instead of the dialog. The new control affords all the capabilities of the dialog. You can Find Next, Find Previous, set Search Options, Replace etc.

Performing a simple Find

With the new Find control, you can perform a search exactly as you would with the VS 2010. Just hit Ctrl+F and type the search term. What you would notice however, is that now the search is instant and incremental. As you type, you get the matches highlighted and the first match selected by default. No need to click an additional Find Next button. Hit Enter to navigate among the matches in the document.

Find Next

Find Previous

Performing an Advanced Find

As I mentioned earlier, the new Find control affords all the capabilities of the Find Dialog. This means that you can search using advanced options (Match Case, Match whole word, Use Regular Expression) just the same as in the Find dialog. For this, simply click on the drop down next to the magnifying glass, in the search box. You can also hit Alt+Down when inside the search box.

Notice that setting Search Options acts like a filter instead of starting a new search. So if you searched for “Button”, without Match case, this would highlight all matches – button as well as Button. Checking Match case would filter this result set to only matches for Button (with the uppercase “B”)

MRU (Search History)

Find control maintains a history of the previously performed searches of up to five terms. This is displayed as a MRU (Most Recently Used) list. The list can be accessed by bringing up the dropdown from within the Find search box (or hitting the Alt+Down arrow key)

Performing a Replace

You can perform a Replace operation right within the new control. Just hit Ctrl+H / click on the drop down arrow to the left of the search box. This brings up the expanded version of the Find & Replace control. The replace box is below the Find box. Type your replace term and Hit Enter, or Atl+R or the Replace Next or Replace All buttons.

Replace Next and Replace All

Changing the Scope

The Find control allows you to change the scope for Find & Replace operations. To change the scope, click on the Drop down arrow, as in the case of Replace. This brings up the expanded Find control with the scope selection dropdown.

“No Results” Alert

The Find control allows you to quickly find out when there are no results for the current search term with the current search criteria. When there are no results to show, the search box is highlighted with a red border indicating that there are currently no results to display.

Using Regular Expressions (.NET Regular Expression syntax only)

One of the major changes we have made, in response to customer feedback, with the new Find experience is moving away from the POSIX style regex syntax to .Net Regex syntax. You can do all your searches using the familiar .Net style regular expressions. The VS2010 style regular expression syntax has been discontinued. So, to search for a “Start Game”, I would type

In Visual Studio 11 Developer Preview: Start\s+Game

In VS 2010 (This will not work in VS 11 Developer Preview): Start:b+Game

A complete reference for .NET Regular expressions can be found here .NET Regular Expression Cheat Sheet.

Find In Files Dialog

You can still do everything that you were used to doing with VS2010 Find Dialog with the new experience. To bring up the Find In Files dialog, simply hit Ctrl+Shift+F (or Ctrl+Shift+H for replace). This brings up the familiar dialog. We have simplified this dialog to a large extent. There are just 2 tabs – Find In Files and Replace In Files.

Find In Files

Now there are only two tabs – Find In Files and Replace in Files. We have added Find Next and Find Previous. Note that you can also bring up the Find In files dialog from within the Find control, in the Search Options dropdown.

Find Symbol has been discontinued

With the new Find experience we have relooked at the Find dialog and redesigned it for simplicity. Based on the usage data we have received from our Customer Experience Improvement program, the Find Symbol features was rarely ever used by our customers. With the new Find, the support for Find Symbol has been removed from the UI. However, you can still search for symbols using the Find All References from within the Editor.

Find & Replace Cheat Sheet

You can of course use the same short-cuts and accelerator keys that you are used to with the Find dialog, with the Find control. Here is a list of shortcuts and accelerator keys you can use to work with Find & Replace in Visual Studio 11 Developer Preview.

Shortcuts:

Command	VS 11 Developer Preview Action	Command
Ctrl+F	New Quick Find	Edit.Find
F3	Find Next	Edit.FindNext
Shift+F3	Find Previous	Edit.FindPrevious
Ctrl+F3	Find Next Selected term	Edit.FindNextSelected
Ctrl+Shift+F3	Find Previous Selected term	Edit.FindPreviousSelected
Ctrl+I	New Quick Find / Forward incremental search	Edit.IncrementalSearch
Ctrl+Shift+I	New Quick Find / Reverse incremental search	Edit.ReverseIncrementalSearch
Ctrl+Shift+F	Find in Files	Edit.FindInFiles
Ctrl+Shift+H	Replace in Files	Edit.ReplaceinFiles
Ctrl+H	Quick Replace	Edit.Replace
Enter	Find Next	Edit.FindNext
Shift+Enter	Find Previous	Edit.FindPrevious

Accelerator Keys:

Shortcut	VS 11 Developer Preview Action
Alt+F	Find Next, Find All (buttons)
Alt+R	Replace, Find Next
Alt+A	Replace All (button)
Alt+I	Skip File (button
Alt+C	Toggle Match Case
Alt+W	Toggle Whole Word
Alt+E	Toggle Regular Expressions
Alt+N	Focus in Find What Box
Alt+P	Focus in Replace With Box

We want to hear from you!

Because Find is such a critical and integral part of the Developer experience, we need your feedback on how well the new experiences are (or are not!) working for you. We are listening to your feedback.

If you have any additional questions, feel free to leave comments below. If you’re experience problems with Find & Replace, please file a Connect Bug, and we’ll investigate

You can write to us here: VSFindFeedback2@microsoft.com

You can also send your feedback from within the Find control:

Thanks,
Murali Krishna Hosabettu Kamalesha
Program Manager - Visual Studio Code Experience

Known Issues

As you might imagine, with the new release, we have completely revamped the Find experience for our customers. With this huge change, there are some known issues and unfortunately we didn’t have time to fix by the time of this release of Visual Studio 11 Developer Preview. However, these issues are already fixed in internal builds and you would be able to get these when you install a subsequent release J.

Unable to Find All with the Current Document scope

In the current version, you will not be able to perform a Find All when the scope is current document. However, when you search for a term using the new Find Control, all of the matches in the current document are highlighted. This should hopefully allow you to work around this issue. And like I mentioned, this issue has been fixed for a subsequent release.

Find in Files does not clear the Find results

In the current version, when you perform a Find in Files, the results are appended to the Find Results window. The results of the previous search are not cleared. To work around this issue, you can still clear out the Find Results window manually. We understand this is inconvenient and this has been fixed, but you will have to wait for a subsequent release. J

Search Criteria is missing from the Find Results window

When you perform a Find All operation, the search results are populated in the Find results window. In the current version, the results are still populated, but a line mentioning the search criteria is missing. For subsequent releases, this issue is also fixed.

Visual Studio BUILD sessions and Tips & Tricks Cheat Sheet

Weston Hutchins - MSFT — Mon, 19 Sep 2011 22:10:00 GMT

As I settle back into my desk after an exciting week at BUILD, I wanted to send a reminder that all of the sessions should be available for streaming on http://channel9.msdn.com/events/BUILD/BUILD2011.

Since this is a Visual Studio blog, here are links to the main VS sessions at BUILD:

What’s new in Visual Studio 11 – Jason Zander
Tips & Tricks: How to Use Visual Studio to the Fullest – Weston Hutchins and Phil Price
What's new in Visual Studio 11 for Application Lifecycle Management – Cameron Skinner and Brian Keller

For the Tips & Tricks talk, Phil and I created a “cheat sheet” of the features and tips we walked through in the session that you can download below.

Thanks,
Weston Hutchins
Program Manager – VS Platform

Addressing Visual Studio performance

Visual Studio Blog — Fri, 16 Sep 2011 21:31:00 GMT

Visual Studio’s performance continues to be a hot topic for a lot of customers. We hear you and are investing to improve the performance of the product in those areas that are important to you. There are two key parts to our approach:

Collecting feedback from you to prioritize our work
Using instrumentation in Visual Studio v-next to collect data in cases where the product performs poorly

Collecting Customer Feedback
We are working to make your feedback less ad hoc and give you a single place for feedback on Visual Studio Performance by implementing a UserVoice site specifically focused on performance. Please vote on the performance issues on the UserVoice site. This feedback will be incorporated into our plans as we prioritize our work.

Instrumentation
Visual Studio PerfWatson is now a part of Visual Studio v-next. It enables us to collect data from when you experience a performance problem. This blog post describes how we are using the data to identify and fix performance problems. You can help by using PerfWatson with Visual Studio v-next. By combining your feedback with this data we a working to address those issues affecting you the most.

Thank you for your support,

Larry Sullivan
Director of Engineering

Visual Studio 11 Developer Preview Announced

Sean Laberee — Wed, 14 Sep 2011 16:38:00 GMT

Today in his keynote at BUILD, Jason Zander announced the availability of the .NET Framework 4.5 Developer Preview, Microsoft® Visual Studio® 11 Developer Preview and Microsoft® Team Server Preview. If you are an MSDN subscriber, you can download the preview immediately via this link. For everyone else, Visual Studio 11 and Team Foundation Server 11 will be generally available starting at 10:00 AM PDT on Friday.

What’s New in the Visual Studio 11 IDE?

A key goal with the Visual Studio 11 release was to improve the developer experience by focusing on the tasks that developers do the most frequently. In our research, we found that many users weren’t discovering features that could make them most productive. To solve this, we streamlined our UI and enhanced high usage tool windows such as the Solution Explorer so that its easier than ever to discover and use the features that make you most productive. Users also want to use search as a primary means of navigating their IDE and Solutions and so we’ve integrated search and made it more prominent in many places in the product.

One of the first changes that you’ll notice as you get started with Visual Studio 11 are the Simplified Toolbars. In the image below, you can see that we’ve eliminated the clutter and ensured that you only ever need one row of toolbars to get your job done. This was accomplished by taking a hard look at each of the commands that was on the main toolbars and focusing only on the commands that are more frequently used on the toolbars. We also know that the most frequently used commands vary by user which is why we’ve made it easy to add commands back via the down arrow on the toolbar.

Many of you may already be familiar with the Productivity Power Tools which are a set of popular extensions to Visual Studio 2010. One of the key themes in the Power Tools was to provide users with better search capabilities. Based on user feedback, we have taken the best of these features and fully-integrated them into Visual Studio 11. The improved Solution Explorer (shown below) allows you to search and browse the relationships of types and members within VB, C# and C++ projects. The new Find Control integrates the power of incremental search with a streamlined UI that ensures that your code remains front and center. Quick Launch is an integrated version of the Quick Access power tool that allows you to easily launch project templates, commands and options for a searchable UI that is always present on the main menu. We’ve also added search capabilities to the Toolbox and Add Reference Dialog.

In past releases, evaluating a CTP or Beta took a bit of work as it required upgrading your projects to the new version. With this Developer Preview, we have introduced Project Compatibility which eliminates the need to upgrade most project types so that you can seamlessly work on the same solution using Visual Studio 11 or Visual Studio 2010 SP1.

Related Blogs

Visual Studio 11 contains many more IDE enhancements than can be called out in a single blog post. Over the coming weeks, stay tuned to this blog for more articles that talk about these features in depth and introduce some new ones. I’d also like to highlight that each of the languages in Visual Studio have made significant improvements to their developer experience and the best place to learn about them is on their team blogs:

VB Team Blog: http://blogs.msdn.com/b/vbteam/

C# Team Blog: http://blogs.msdn.com/b/csharpfaq/

C++ Team Blog: http://blogs.msdn.com/b/vcblog/

F# Team Blog: http://blogs.msdn.com/b/fsharpteam/

We Want Your Feedback!

Your feedback is an important part of our software development cycle. We review every comment that we receive and are constantly using this feedback to improve the product. If you encounter a bug or find something that doesn’t work as you would expect, please log on to Microsoft Connect and file a bug: https://connect.microsoft.com/VisualStudio. If you have a suggestion for a great new feature addition, take a look at our User Voice site where you can vote on other user suggestions and add your own: http://visualstudio.uservoice.com/forums/121579-visual-studio.

Sean Laberee

Lead Program Manager

Visual Studio Pro Experience Team

How we use your PerfWatson data to identify Unresponsive areas

Visual Studio Blog — Wed, 24 Aug 2011 12:37:00 GMT

At the end of April, we released a telemetry system to monitor and report the performance issues that our customers face during their everyday use of the product. To start off, I would like to thank everyone who installed Visual Studio PerfWatson! These reports have provided valuable insight into where you are encountering issues, and have helped us prioritize our performance investments for the next version of Visual Studio (“vNext”).

How are we using PerfWatson Data?

As many of you have seen, PerfWatson monitors delays on the UI thread, and submits error reports on these delays with the user’s consent. These reports include information on the duration of each delay and a mini heap dump of the root cause for the delay.

When we receive these error reports, we aggregate the data collected, extract the stacks from the mini dump, and analyze the results to identify the largest and most frequently seen delays. We also aggregate the data collected with the delays we have seen using PerfWatson internally. Periodically throughout each milestone, bugs are generated for each team in the division to track the specific subsets of frames (or methods) that are responsible for these performance issues.

Bugs are prioritized based on a combination of the total number of delays we have seen with that frame and the average length of the delay. This ensures that both very long delays and frequently encountered delays receive our attention. Because we have live data associated with each bug, we can track progress across the entire product, within specific teams, and also across internal “dogfood” builds, enabling teams to easily verify the progress they are making.

Below is an example of a bug we have fixed for vNext. The PerfWatson data shows that this bug was reported 16588 times in total for the released build of Visual Studio 2010 SP1. This data is an aggregation of all results we have collected both internally and from our customers.

Total PerfWatson hits per build. X axes are subsequent build numbers.

As the chart below shows, after fixing the bug, the number of delays seen for this issue has gone down significantly or have completely disappeared with every new build of the product created with the code fix.

Total PerfWatson hits per build. X axes are subsequent build numbers.

If you are interested in learning more about this process, or seeing some of the tools in action, check out this Channel9 video, where Cameron McColl from our product team discusses these mechanics in more detail.

So with all the data we have collected so far, what trends have we seen? Below are three areas that have stood out:

Solution Open

While we had received feedback that loading a solution can be slow, PerfWatson has given us a much clearer picture into where, specifically, delays are most likely to occur. A number of steps take place when a solution is opening, each contributing a certain amount of cost to the overall experience. However, when looking at the data, we’ve found that several tasks were more expensive than we expected. For example: reopening files that were open in the last session, or retrieving the solution settings, such as breakpoints and window layout, from SUO file (Solution User Options) can take more than a few milliseconds extending the overall cost of loading the solution.

One way we have found to help improve this experience is to reduce the overall document clutter. There are several ways that a number of files get opened besides clicking on them in Solution Explorer – Go To Definition, Debugging, Find etc. This experience has now been simplified with the introduction of a “preview tab” for opening files that are not yet needed by the user. This new IDE feature was demoed during the TechEd conference held mid-May (see Channel 9 coverage at 00:27:20 minute marker).

In addition to simplifying certain scenarios like opening files, the Visual Studio team is investigating several ways to optimize the solution open scenario for vNext. One method, for example, we are investigating is moving operations away from solution load time to when there is less competition for system resources. The PerfWatson data is helping us understand which areas would benefit from applying these improvements along with making sure there are no regressions.

Idle Loop Processing

Visual Studio has a mechanism for components to queue up non-blocking work for a time when CPU cycles are less constrained (aka, the system is “idle”). These idle operations take place on the UI thread when the message queue is empty. For information on Idle Loop Processing please refer to the MSDN documentation here.

This mechanism worked well when the product was smaller, processors were single core, and only a few operations utilized this mechanism. However, as the product has grown, this mechanism has hit its scalability limits as more tasks have started to schedule recurring computations and expensive IO operations during the “idle loop”.

PerfWatson has enabled us to quickly identify which of these scheduled tasks can become potentially expensive. The following are a few examples that we are tracking as bugs:

Refreshing the Task and Error Lists.
Initializing the Toolbox.
Updating the outlining for VC++ code windows.
Updating command bars and menus.
Saving backup copies of all open files for auto recovery.

For each task, we look at a variety of ways to improve the performance. For tasks which iterate on large data sets, we look at ways to break assumptions that the operation needs to be completed as a single operation. This allows the task to be partitioned into much finer increments, quickly yielding back to the UI thread. For example, our Auto-recover mechanism has been updated to do this. Rather than saving all changed documents at once, we instead save one at a time, yielding back to the UI thread after each save. For others, we’ve rewritten the tasks to execute asynchronously off of the UI thread, allowing us to take better advantage of multi-core hardware and remove expensive IO operations from the UI thread.

Idle issues are not easy to reproduce; however with the use of PerfWatson data collected both internally and from you, our customers, we have been able to identify and open bugs for over 30 idle specific issues.

Build

PerfWatson data indicates that one of the more frequent areas that cause the IDE to be unresponsive is solution build. For vNext, we have made significant investments to improve the overall build responsiveness by moving the build off the UI thread for VB and C# builds (C++ already does this). This feature was demoed at the TechEd conference (Channel 9 coverage at 00:45:00 minute marker).

As part of doing this work, we found that not only could we make the UI more responsive during build but, for C#, we were even able to parallelize the build, improving both build throughput and memory utilization. (VB was best optimized by moving it off the UI thread).

We hope this blog post has given you some insight into how we’re using the PerfWatson data to make improvements to the product. Thanks again to everybody who has already downloaded and installed the extension. For those of you who have not yet done so, the extension can be downloaded from here. As always, we welcome your comments and feedback!

Thanks!

Shibani Basava
Software Development Engineer in Test, VS Team

High school students at the Academy of Interactive Entertainment build a WP application from scratch in a week

Visual Studio Blog — Wed, 17 Aug 2011 07:17:00 GMT

By Alice Lee

Developing a full-fledged Windows Phone app in one week – that’s pretty ambitious, right?

Last week, at the Academy of Interactive Entertainment (AIE)’s weekly Summer Cyber Camp, a team of talented high and middle school students set out to do just that. I followed them for one week, documenting the process of creating their 3D game for Windows Phone 7 (WP7), called Color Break. Some of the students began with minimal programming experience while others had been using C# for a few years. At the end of the week, however, they were all capable of writing code, creating graphics, and incorporating more advanced concepts such as physics into the game. By Friday, they’d finished and ported the application to the phone - just five days later (check out the app in action in the video)! It just goes to show that whether you’re an absolute beginner or a seasoned expert, developing for the WP can be a simple, fun, and extremely educational process. One student, who had never even coded in C# before, began developing a first person shooter. As a college student myself, I was impressed.

So, how do you get started? Well it’s simple – check out http://create.msdn.com to access the plethora of resources, downloads, and tutorials. If you’re a student, there are also a ton of free, easy-to-use WP-related development tools available, including:
- Dreamspark (http://dreamspark.microsoft.com), to get access to Visual Studio 2010 Professional, the IDE that the students are using in this video.

- The Windows Phone Student Developer page (http://www.microsoft.com/student/en/us/techstudent/handson/phone-development.aspx) for resources as well as a student developer account to get started.

Feedback Opportunity: Command Complexity in Visual Studio

Visual Studio Blog — Fri, 27 May 2011 00:34:00 GMT

By Sam Zaiss

Update: We're happy to set anyone up with the new reduced toolbar set, whether you are in the US or not. Unfortunately the rule about the Microsoft gratuity is strict, but if you're willing, we'd still love to get your feedback. Please send mail to VSToolbarFeedback@microsoft.com if you're interested.

Update 2: Thanks everyone for your interest! The formal survey is now full, and the gratuities have all been claimed. However, we're still happy to share the reduced toolbars with any interested customer. Please contact VSToolbarFeedback@microsoft.com if you're interested in checking it out; we can still accept your feedback via email!!

One thing that we hear about is how daunting Visual Studio can be for newcomers, and customers have told us that the abundance of commands in VS definitely plays a role in that perception. As we work on the next release of Visual Studio, my core focus has been to find ways we can get our command complexity under control without taking away any of the functionality that our customers depend on.

Improving the state of the VS toolbars is one area that we’re taking on for vNext. Today, it’s entirely possible to end up with 2-3 completely full rows of toolbars:

Not only does this take away space from your code, but toolbars that show/hide for specific files can also cause your document tabs to vertically shift when switching from one file to another. We know we can do better! Keeping the toolbars confined to a single row is a goal for our next release.

We have a good start on this work, but now we need your feedback! If you’re currently using Visual Studio 2010 (with or without SP1) for 20+ hours a week, we’d like to set you up with a single row of toolbars, and get your feedback on the reduction choices we’ve made. Here’s what would be involved:

We’d send you a settings file that, when imported, will reduce your toolbars down to one row. It won’t remove any functionality from VS, nor will it do anything besides rearrange your toolbars. The change can be easily undone at any time.
Work as you normally would for a week. If you run into any issues with the reduced toolbars, make a note of them.
At the end of the week, fill out a survey to let us know what you think. As a thank you, the first 150 people to participate will receive a Microsoft Gratuity*, which entitles you to one free piece of Microsoft software or XBox 360 game!

* Due to regulations around Microsoft Gratuities, we can unfortunately only accept participants who have a US Social Security Number or Tax ID number. [Update] However, we are more than happy to set any interested customer up with the settings file and accept their feedback. Please feel free to send mail and we'll get you set up!

If you’re interested in participating, please send mail to VSToolbarFeedback@microsoft.com and we’ll get you set up!

Thanks!
Sam Zaiss
UX Researcher, Visual Studio IDE Platform & Editor

TechEd 2011: Visual Studio vNext Sneak Preview

Weston Hutchins - MSFT — Thu, 26 May 2011 02:46:42 GMT

In case you missed it, last week at TechEd 2011 in Atlanta, GA, I gave conference attendees a first look at some of the new IDE features and performance improvements we’re working on for the next version of Visual Studio. Channel9 has posted the session (along with all the other TechEd sessions) so everyone else can now watch the presentations and demos. Take a look, and let us know what you think!

Microsoft Visual Studio IDE Futures - http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV326

There were also a number of other Visual Studio and language sessions that might interest you:

Weston Hutchins
Program Manager – VS IDE Platform

New Channel 9 Series: Visual Studio Toolbox

Weston Hutchins - MSFT — Wed, 11 May 2011 20:26:00 GMT

The debut episode of the Visual Studio Toolbox, a new Channel 9 series focused on Visual Studio tips and tricks, is now live! In the first episode, Robert Green walks through the features of the Solution Navigator tool window included in the Productivity Power Tools, showing you how to efficiently navigate your code. Check it out and let him know what you’d like to see in future episodes!

Visual Studio Toolbox: Productivity Power Tools Part 1 (17 min)

Using PerfWatson to report performance issues to Microsoft

Visual Studio Blog — Mon, 02 May 2011 21:11:00 GMT

By Selma Ikiz

Would you like Visual Studio 2010 to be even faster? Would you like any performance issue you see to be reported automatically without any hassle? Well now you can, with the new Visual Studio PerfWatson extension! Install this extension and help us deliver a faster Visual Studio experience.

We’re constantly working to improve the performance of Visual Studio and take feedback about it very seriously. Our investigations into these issues have found that there are a variety of scenarios where a long running task can cause the UI thread to hang or become unresponsive. Visual Studio PerfWatson is a low overhead telemetry system that helps us capture these instances of UI unresponsiveness and report them back to Microsoft automatically and anonymously. We then use this data to drive performance improvements that make Visual Studio faster.

Here’s how it works: when the tool detects that the Visual Studio UI has become unresponsive, it records information about the length of the delay and the root cause, and submits a report to Microsoft. The Visual Studio team can then aggregate the data from these reports to prioritize the issues that are causing the largest or most frequent delays across our user base. By installing the PerfWatson extension, you are helping Microsoft identify and fix the performance issues that you most frequently encounter on your PC.

To enable PerfWatson perform correctly, please make sure that Windows Error Reporting (WER) is enabled on your machine. PerfWatson employs WER service to send the collected data to Microsoft. For details on WER and how to enable it, please refer to PerfWatson blog.

Download and Installation

Following are the pre-requisites for installing Visual Studio PerfWatson:

Windows Vista/2008/2008 R2/7 (Note: PerfWatson is not supported for Windows XP)
Visual Studio 2010 SP1 (Professional, Premium, or Ultimate)

The extension can be downloaded from the Visual Studio Extension Manager or at the VS Gallery.

Limitations

The tool doesn’t work on Windows XP
The tool needs WER be enabled. For details on how to enable WER, please see this blog post

Please let us know what you think! Thanks!

The Visual Studio Blog

Bring Some Game To Your Code!

Bring Some Game To Your Code!

Learn More About Visual Studio

Download It

How It Works

Share Your Flair

Genesis

Feedback

Give us your feedback on Visual Studio 11 etc. and receive a gift!

Microsoft Windows Simulator Rotation and Resolution Emulation

Rotation and Orientation-Aware Application

Orientation-Aware Application: HTML/CSS Binding

Orientation-Aware Application: Binding through Event Handler

Resolution

Debugging Contracts using Windows Simulator

Using Local Debugging

Using Windows Simulator

Visual Studio 2010 SP1 – now available on Microsoft Update

An update on Visual Studio performance

Roslyn Syntax Visualizers

Getting Started

Syntax Visualizer Tool Window

Syntax Debugger Visualizer

Feedback

Introducing the Microsoft “Roslyn” CTP

Today we are releasing the first Community Technology Preview of the Roslyn Project!

What is Roslyn?

Download the October 2011 CTP

Getting Started

Reference Assemblies

C# Interactive window

C# Script File (.csx) Editing Support

Quick sample of the Roslyn API

Visual Studio 11 Developer Preview: Search Everywhere

Search in Solution Explorer

Search in Error list

Search in Other Windows

Quick Launch

Feedback

Improving developer productivity with Visual Studio 11 Developer Preview

Visual Studio 11 Developer Preview Survey

Private Extension Galleries for the Enterprise

Configuring a private gallery

Using your gallery

Creating the gallery

Updating

Microsoft Windows Simulator Touch Emulation

First look at Windows Simulator

Primary Usage Scenarios for Windows Simulator

Under the hood

Using Simulator to debug Metro style applications in Visual Studio

Using the Simulator from Expression Blend

Touch Emulation

Rotation

Multiple screen Resolutions

Contracts

Visual Studio 11 Developer Preview: Quick Launch

Quick Launch: Basic Use

Categories

Most Recently Used

Commands

Options

Open Documents

Turning Categories Off

Large Result Sets

Search Results from Previous Search

Turning It Off

Finally

Visual Studio 11 Developer Preview: Find & Replace

The new Find and Replace Control

Performing a simple Find

Performing an Advanced Find

MRU (Search History)

Performing a Replace

Changing the Scope

“No Results” Alert

Using Regular Expressions (.NET Regular Expression syntax only)

Find In Files Dialog

Find Symbol has been discontinued