Jason Zander's WebLog

Join me at the ALM & Test days in Italy

Jason Zander — Fri, 20 Jan 2012 01:10:00 GMT

I’m looking forward to my upcoming trip to Italy next week, where I’ll have an opportunity to speak at Microsoft events, and spend time with customers and partners. I wanted to share my plans with you, in case we have an opportunity to connect.

The Microsoft events where I will be keynoting are the ALM & Test days. These are single day events, being held in Milan on January 24^th and Rome on January 26^th. The events will focus on Application Lifecycle Management, and will provide useful resources for both business decision makers and technical decision makers. In my keynote, I will describe the Microsoft ALM Strategy. This will be a good opportunity to learn about the direction we’re taking with our Microsoft ALM products, and gain insight into the thinking behind it. I will also share information on what you can expect to see in the next Visual Studio release.

Following my presentation, there will be talks offering insights and learning’s from real-world examples of implementing ALM in the enterprise including CIO interviews, customer panels, and detailed sessions on end-to-end integration by expert partner teams. I look forward to meeting everyone!

Follow me at twitter.com/jlzander.

January 17th What’s Happening Around Visual Studio

Jason Zander — Wed, 18 Jan 2012 02:08:00 GMT

I hope everyone had a great holiday season, and is off to a good new year. I enjoyed taking some time off to spend with my family.

I wanted to share some of what’s been going on in the Visual Studio team since BUILD.

In October we released the Microsoft “Roslyn” CTP. Roslyn is a long lead project (post-Visual Studio 11), in which we’re rewriting the C# and Visual Basic compilers in C# and Visual Basic! In the process, we’re opening up these compilers as APIs that are accessible to developers. This is a significant shift from traditional black box compilers, where source code goes in and assemblies come out. One advantage of opening up these compilers is that it will make it easier to create amazing tools for these languages. We’re looking forward to seeing what you will build with this support. For more information on “Roslyn”, please visit http://msdn.com/en-us/roslyn.

In November we released the latest Windows Azure SDK for .NET, which included updates to the Windows Azure Tools for Visual Studio 2010 and the Windows Azure Emulator. If you’ve been targeting Windows Azure, a couple of improvements you’ll enjoy are the Publish Windows Azure Application wizard and command-line build support. For the full list of changes, please see the Windows Azure team blog post or the Windows Azure documentation. If you’re new to Windows Azure, there are also some great new resources to get you started, such as the redesigned Windows Azure website at http://www.windowsazure.com/. If you’re looking for hands-on labs, slides, and demos, be sure to also download the Windows Azure Training Kit. For presentations, I recommend watching the session videos from the recent Learn Windows Azure event in December.

Following the Windows Azure release in November, we released a refresh of our Team Foundation Service (Team Foundation Server running on Windows Azure) in December. Team Foundation Service is the fastest and easiest way to get up and running on a team project. Team Foundation Service preview has been running as a private preview since April, and with public invitation codes since September at BUILD. The most recent enhancements in the December release include navigation updates, richer homepages, simplified web UI for small teams, performance, email notifications, forecast lines, and in-tile taskboard editing. These changes are in response to feedback from our early adopters, and make the tool even more helpful and easy to use. We are very interested in your feedback at this point in the product development (both on UserVoice and Connect), so we can make the right improvements as we develop the product. To learn more about the Team Foundation Service preview, please visit Brian Harry’s blog, the ALM Team blog, or Channel9.

December was a big month for TFS. In addition to the Team Foundation Service preview, we also released an update of the Team Foundation Server Power Tools. While the Team Foundation Service preview is an early look at a future technology, the Team Foundation Server Power Tools are an extension to the released product, Team Foundation Server 2010. I’ve blogged about power tools before, and explained that we release them to try out new ideas or answer common requests more quickly than in the next product release. In the December TFS Power Tools release we focused on developers using TFS from Eclipse. We want to make sure that TFS is accessible to developers using any tools, and therefore we add support to additional tools beyond Visual Studio, where it makes sense. Eclipse users can download the December release, and get additional features including TFS alerts, work item templates, and improved Find in Source Control. Another improvement available in the December release is 64-bit MSSCCI support.

In November, I also participated in the ALM Summit which was held at the Microsoft Headquarters in Redmond Washington. This event is a great opportunity to discuss application lifecycle management challenges, learn how to apply Microsoft’s solutions, and pick up best practices from industry experts. At the Summit I gave a presentation on The Microsoft Vision for ALM, which you can find recorded on Channel9. In this talk, I shared the trends I’m seeing in the industry, and how we’re advancing the Visual Studio product offerings to address them. If you missed this event and are interested in ALM, I’d definitely recommend viewing this and the other session videos available online.

Enjoy!

Follow me at twitter.com/jlzander.

Announcing Visual Studio 11 Developer Preview

Jason Zander — Wed, 14 Sep 2011 17:30:00 GMT

Today in the BUILD keynote I had the opportunity to show some of the new functionality in Microsoft® Visual Studio® 11 Developer Preview and Microsoft® Team Foundation Server Preview. MSDN subscribers can download the previews today as well as the new release of .NET Framework 4.5 Developer Preview; general availability is on Friday, September 16.

Download Visual Studio 11, Team Foundation Server 11, and several other components today (MSDN Subscribers Only Downloads).
Friday 10:00 AM PDT general availability for Visual Studio 11 and Team Foundation Server 11 can be downloaded.

Some exciting announcements are being made here at BUILD. Visual Studio 11 provides an integrated development experience that spans the entire lifecycle of software creation from architecture to code creation, testing and beyond. This release adds support for Windows 8 and HTML 5, enabling you to target platforms across devices, services and the cloud. Integration with Team Foundation Server enables the entire team to collaborate throughout the development cycle to create quality applications.

.NET 4.5 has focused on top developer requests across all our key technologies, and includes new features for Asynchronous programming in C# and Visual Basic, support for state machines in Windows Workflow, and increased investments in HTML5 and CSS3 in ASP.NET.

We’ve shared a lot at BUILD already, for more on the future of Windows development I suggest you take a look at Steven Sinofsky and S. Somasegar’s blogs. More details on Team Foundation Server including the new service announced at BUILD and how we’re helping teams be more productive can be found on Brian Harry’s blog.

Quick Tour around Visual Studio 11 Features

Visual Studio 11 has several new features, all designed to provide an integrated set of tools for delivering great user and application experiences; whether working individually or as part of a team. Let me highlight a few:

Develop Metro style Apps for Windows 8

Visual Studio 11 includes a set of templates that get you started quickly developing Metro style applications with JavaScript, C#, VB or C++. The blank Application template provides the simplest starting point with a default project structure that includes sample resources and images. The Grid View, Split View, and Navigation templates are designed to provide a starting point for more complex user interfaces.

From Visual Studio 11, seamlessly open up your Metro style app with JavaScript in Expression Blend to add the style and structure of your application.

Due to the dynamic nature of HTML it is often difficult to see how a web page is going to look unless it is running. Blend’s innovative interactive design mode enables you to run your app on the design surface as a live app instead of a static visual layout.

Enhancements for Game Development

We have added Visual Studio Graphics tools to help game developers become more productive, making it easier to build innovative games. Visual Studio 11 provides access to a number of resource editing, visual design, and visual debugging tools for writing 2D / 3D games and Metro style applications. Specifically, Visual Studio Graphics includes tools for:

Viewing and basic editing of 3D models in Visual Studio 11.

Viewing and editing of images and textures with support for alpha channels and transparency.

Visually designing shader programs and effect files.

Debugging and diagnostics of DirectX based output.

Code Clone Analysis

Visual Studio has historically provided tools that enable a developer to improve code quality by refactoring code. However this process depends on the developer to determine where such reusable code is likely to occur. The Code-Clone Analysis tool in Visual Studio 11 examines your solution looking for logic that is duplicated, enabling you to factor this code out into one or more common methods. The tool does this very intelligently; it does not just search for identical blocks of code, rather it searches for semantically similar constructs using heuristics developed by Microsoft Research.

This technique is useful if you are correcting a bug in a piece of code and you want to find out whether the same bug resulting from the same programmatic idiom occurs elsewhere in the project.

Code Review Workflow with Team Explorer

Visual Studio 11 Preview works hand in hand with Team Foundation Server 11 to provide best in class application lifecycle management. Visual Studio 11 facilities collaboration is by enabling developers to request and perform code reviews through using Team Explorer. This feature defines a workflow in Team Foundation Server that saves project state and routes review requests as work items to team members. These workflows are independent of any specific process or methodology, so you can incorporate code reviews at any convenient point in the project lifecycle.

The Request Review link in the My Work pane enables you to create a new code review task and assign it to one or more other developers.

The reviewer can accept or decline the review, and respond to any messages or queries associated with the code review, add annotations and more. Visual Studio 11 displays the code by using a “Diff” format, showing the original code and the changes made by the developer requesting the review. This feature enables the reviewer to quickly understand the scope of the changes and work more efficiently.

Exploratory Testing and Enhanced Unit Testing

As development teams become more flexible and agile, they demand adaptive tools that still ensure a high commitment to quality. The Exploratory Testing feature is an adaptive tool for agile testing that enables you to test without performing formal test planning. You can now directly start testing the product without spending time writing test cases or composing test suites. When you start a new testing session, the tool generates a full log of your interaction with the application under test. You can annotate your session with notes, and you can capture the screen at any point and add the resulting screen shot to your notes. You can also attach a file providing any additional information if required. With the exploratory testing tool you can also:

File actionable bugs fast. The Exploratory Testing tool enables you to generate a bug report, and the steps that you performed to cause unexpected behavior are automatically included in the bug report.

Create test cases. You can generate test cases based on the steps that caused the bugs to appear.

Manage exploratory testing sessions. When testing is complete, you can return to Microsoft Test Manager, which saves the details of the testing session and includes information such as the duration, which new bugs were filed, and which test cases were created.

What’s New in .NET 4.5

.NET 4.5 has focused on our top developer requests. Across ASP.NET, the BCL, MEF, WCF, WPF, Windows Workflow, and other key technologies, we’ve listened to developers and added functionality in .NET 4.5. Important examples include state machine support in Windows Workflow, and improved support for SQL Server and Windows Azure in ADO.NET. ASP.NET has increased investments in HTML5, CSS3, device detection, page optimization, and the NuGet package system, as well as introduces new functionality with MVC4. Learn more at Scott Guthrie’s blog.

.NET 4.5 also helps developers write faster code. Support for Asynchronous programming in C# and Visual Basic enables developers to easily write client UI code that doesn’t block, and server code that scales more efficiently. The new server garbage collector reduces pause times, and new features in the Parallel Computing Platform enable Dataflow programming and other improvements.

Start Coding

Visual Studio 11 includes several new features which will help developers collaborate more effectively while creating exciting experiences for their users. Here are some are some resources to help you get started.

Enjoy!

Microsoft® Visual Studio® LightSwitch™ 2011 is Available Today

Jason Zander — Tue, 26 Jul 2011 17:00:00 GMT

I am happy to say that as of 10:00am PDT today, Microsoft Visual Studio LightSwitch 2011 is available! MSDN subscribers can download LightSwitch immediately and others can download the 90-day trial. General availability is on Thursday, July 28th.

Get Visual Studio LightSwitch 2011 (MSDN Subscribers). If you’re not a MSDN Subscriber, you can download a 90 day trial.
Thursday’s 10:00am PDT general availability information can be found on the LightSwitch site.

Visual Studio LightSwitch 2011 is a simplified, self-service development tool that enables you to create business applications quickly and easily for the desktop and cloud. I first announced LightSwitch at the VS Live conference in August 2010 and have since written a few posts including detailed tutorials. For those of you unfamiliar with it, it starts with the premise that most business applications consist of data and the screens that users interact with. LightSwitch simplifies attaching to data with data source wizards or creating data tables with table designers. It also includes screen templates for common tasks so you can create clean interfaces for your applications without being a designer. Basic applications can be written without a line of code. However, you can add custom code that is specific to your business problem without having to worry about setting up classes and methods.

As part of today's announcement, I've put together a video that highlights some of the features within LightSwitch, along with sessions on how to build applications using it.

Visual Studio LightSwitch Key Features

LightSwitch provides several features to streamline development of business applications. Some of the key features are:

Starter Kits
To jump start your development we created starter kits for common types of business applications. Check out the available starter kits to find the one that best fits your needs and use it as the starting point for your business application. Downloaded starter kits appear in your installed templates.

Publish to Azure
Take your LightSwitch applications to the cloud by publishing to Azure directly from the IDE. You don’t need to rewrite your application; simply change the target environment, follow the steps and then your application is published to Azure.

Azure publishing does not only include running your application from the cloud— you can also distribute it from Azure. Desktop applications can be shared from a single location for others to download.

LightSwitch Extensions
LightSwitch applications are extensible, giving you the flexibility to update your application in the future with minimal disruptions. Extension points are business data types, screen templates, data sources, themes, shells and custom controls. In addition to being able to create your own extensions, our launch partners, ComponentOne, DevExpress, First Floor Software, Infragistics and RSSBus, are making a variety of extensions available for use today. You can get more details on the extensions each partner created on the LightSwitch site or from within the Extension Manager in LightSwitch.

Select the extension for use in your current project or for use in all future LightSwitch applications.

LightSwitch extensions require minimal effort to include them in an application. Often selecting them from a drop-down menu is sufficient, or for more advanced ones may require configuration or some code.

Once the extension is added you can use it within your application.

Summary

Thanks to all of you who downloaded pre-release builds of the product and provided your feedback. Your feedback has been invaluable to us.

You can find additional information, training resources, and guidelines for moving your existing Beta 2 projects forward on the LightSwitch team blog. Here is an additional list of helpful links:

LightSwitch Site
LightSwitch Developer Center (one-stop-shop for training content and the community)
LightSwitch on Facebook
LightSwitch on Twitter (hash tag: #LightSwitch)
LightSwitch Readme
LightSwitch Forums
LightSwitch Connect Site (feedback)

Enjoy!

Jason

June 28th What's Happening Around Visual Studio

Jason Zander — Tue, 28 Jun 2011 18:51:00 GMT

A quick recap of what's been happening on the team.

Unit Testing Windows Phone 7 applications - Amit Chatterjee continues his series of posts as he builds his Chronometer Windows Phone 7 application.
TFS 2010 SP1 Cumulative Update 1 Available - Learn about the latest cumulative update from the TFS team. The update prereqs SP1 and should be installed on TFS application tiers and build servers.
Visual Studio ALM Rangers - Just recently, the Ranger community launched two sets of guidance that I recommend you check out. The Visual Studio Build Customization Guidance offers scenario based guidance on versioning, code signing, and branching. The Visual Studio Lab Management Guidance is designed for professional deployment of Lab Management in production environments.
Agile Project Management in Visual Studio ALM V.Next - Brian Harry walks through how the TFS team adopted Scrum for their feature team level development.
Kinect SDK for PC - VB Samples available - Download Kinect for Windows SDK beta and start coding using the available VB samples.
The Importance of Feedback in Software Development - Learn how by increasing the role of interation and feedback in your development process you can build better software.
VS ALM Library Updates on MSDN for May 2011 - Check out the latest content published in our Visual Studio Library.
Make Agile Work for you in TFS 2010 - Chris Adams recently wrote an article for MSDN Magazine that takes you on the journey of his team's adoption of Agile practices using Team Foundation Server 2010.
Micro-framework v4.2 Support for Visual Basic - Check out how VB developers can now be microcontroller developers.
New QFE for Visual Studio 2010 testing tools - The team recently made available a QFE that fixes some issues reported by our customers. Check out the team blog for a summary of issues fixed.
Tips and Tricks for Using the Screen Designer - Sheel Shah walks through how to get the most out of your screen designer using LightSwitch.

Enjoy!

Follow me at twitter.com/jlzander.

Please welcome Erich Gamma to the Visual Studio team!

Jason Zander — Mon, 06 Jun 2011 12:00:00 GMT

Today I am thrilled to announce that Erich Gamma will be joining the Visual Studio team as a Microsoft Distinguished Engineer! Erich’s contributions have had a huge impact on the software industry. Erich has a passion for shipping high quality, elegant software, something he shared with the community as co-author of Design Patterns. He has always had a passion for building tools to make development more productive and pleasant. Together with Kent Beck he developed the JUnit unit test framework. He was one of the key technical leads of the Eclipse project and he has lead the Eclipse Java Development tools. Recently his focus was on making teams more effective. He was an initial member of the Jazz project and the technical lead of Rational Team Concert. Finally, Erich has worked to bring teams together across the application life cycle and he was the lead of Rational's Collaborative Lifecycle Management effort.

Erich will continue to live and work out of Zurich, Switzerland where we will be opening a small Visual Studio development lab with Erich as the lead. Erich will join the lab in early August. For those who are interested in applying for positions with the new Zurich lab you can send mail to CHDevDiv@Microsoft.com to get details.

The Visual Studio team is passionate about inspiring developers to create great software. We want to make developers successful and enable them to continuously deliver value. We are constantly looking for better ways to accomplish these goals. I’m very excited to have someone like Erich who shares our passion join the team. Please join me in welcoming Erich to the Visual Studio team!

Jason

May 27th What's Happening Around Visual Studio

Jason Zander — Fri, 27 May 2011 19:03:00 GMT

Last week was Teched North America in Atlanta, GA. It was a great event and continues to be one of my favorite conferences because we get the chance to engage with both developers and IT professionals. In addition to my announcement of our ALM Roadmap in Visual Studio vNext, there has been quite a bit of videos and blogs posted that I want to make sure you've had a chance to check out.

While Channel 9 has all the TechEd sessions available - here are a handful of sessions to help get you started:

Keynote Address (Robert Wahbe, Jason Zander)
The Future of Microsoft Visual Studio Application Lifecycle Management (Cameron Skinner)
Building Business Applications with Microsoft Visual Studio LightSwitch (Robert Green)
Visual Studio IDE Futures (Weston Hutchins)
How We Do Language Design at Microsoft (Alex Turner, Donald Syme, Lisa Feigenbaum, Lucian Wischik)
Team Foundation Server for Everyone (Martin Woodward)
Manual Testing with Microsoft Test Manager 2010 (Brian Keller)
ALM for C++ in Microsoft Visual Studio 2010 (Terry Leeper)

There have also been more details behind the announcements in a few of our team blogs.

Connecting Development and Operations - Learn more about the TFS-SCOM connector, our first step in the journey of connecting the development and operations team together.
3 Easy Ways to Learn About Visual Studio nNext Application Lifecycle Management - Check out Brian Keller's post that is a great help for getting up to speed on what we announced at Teched NA.
ALM for C++ in Visual Studio vNext at TechEd NA 2011 - Learn about some of the new features that will be especially useful to C++ developer teams.

Additional things happening around the Visual Studio team:

Windows Phone Developer Tools 7.1 Beta - Download these tools and start building apps and games. The beta includes Visual Basic support for XNA and Windows Phone. To learn more check out the Visual Basic Support in XNA Game Studio 4 article and the team's post regarding VB support for the XNA platform.
Visual Studio Toolbox - Check out Robert Green's new series on Channel 9 that focuses on our tooling with the goal of helping you become a more productive developer.
TFS and Project Server Resources - Take advantage of the recent resources (videos, virtual machine) the team has made available to help you manage enterprise development projects.
Configuration matrix testing using Visual Studio Lab Management - Learn how to test your application in both IE and Firefox.
Import Data While Running a LightSwitch Web Application - Check out Matt Sampson's tips and tricks that makes this seemlingly tricky process pretty easy to understand.
Happy 20th Birthday Visual Basic! - Check out all the stories and best wishes from the community - Happy Birthday VB!

Enjoy!

Follow me at twitter.com/jlzander.

Announcing ALM Roadmap in Visual Studio vNext at Teched

Jason Zander — Mon, 16 May 2011 14:04:00 GMT

I get a lot of questions about the future of Visual Studio; while I can't talk about everything we're doing I am excited because today at Teched North America, I announced our vision for Application Lifecycle Management (ALM) in the next version of Visual Studio. Our vision for ALM can be broken down into three main themes:

Building on the momentum of Visual Studio 2010. If you haven’t tried out Visual Studio 2010, you can take it out for a test drive.
Accelerating agile adoption – you can find great existing support today with more to come.
Linking development and operations – ensuring a tight interaction between dev and ops.

When we asked people what the biggest problem they faced in successfully delivering software, they identified the need for better collaboration. We know that building software takes a team of people including developers, testers, architects, project planners, and more. Out of this observation, we created the strategy for our ALM offering which focuses on helping people collaborate in very tightly integrated ways:

Collaboration – focus on the flow of value between team members no matter what role.
Actionable Feedback – when feedback is required between team members, it should be in a form which is directly applicable to solving the problem at hand. For example when a tester communicates a defect to development it should include videos, screen shots, configuration information, and even an IntelliTrace log making it easier to find and fix the root problem.
Diverse Work Styles – provide the best possible tool for each team member whether that is the Visual Studio IDE, the web browser, SharePoint, Office, or dedicated tooling.
Transparent Agile Processes – Enable all of the above to work on a “single source of truth” from engineering tasks through project status. TFS provides this core that brings together all team members and their tools.

VS2005, VS2008, and VS2010 have all delivered new value following this path. For example VS2010 added deep Architect <-> Developer and Test <-> Developer interaction through solutions like architectural discovery, layering enforcement, automated testing, and IntelliTrace.

In the keynote today, I talked about how we have continued on this path by incorporating two additional important roles: stakeholders and operations. Even though this diagram greatly simplifies the flows throughout the application lifecycle, it captures the essence of planning, building, and managing software:

There are a number of scenarios that span the next version of Visual Studio for ALM. These scenarios improve the creation, maintenance and support of software solutions by focusing on improving the workflow across the entire team as well as across the entire lifecycle.

Agile Planning Tools – create transparency across the planning process and full team participation through solutions like the new backlog and task board.
Lightweight Requirements – a natural way to capture and receive feedback on requirements early in the process.
Stakeholder Feedback – working code which matches the expectations of stakeholders.
Continuous Testing – unit test coverage ensures quality in the final product.
Agile Quality Assurance – increased code quality with code review support, enhanced unit testing frameworks and new exploratory testing support.
Enhanced User Experience – more time ‘in the zone’, through improved experiences for day-to-day tasks.
Aligning Development with Operations – increased connections and insight between the operations and development teams lowering the time it takes to fix a bug in production.

Here are just a few of the screenshots from the demos today – a link to my keynote is below.

Agile Planning
Planning a successful release requires making a lot of tradeoffs. We need to decide what core customer problems we want to solve and in what priority (product backlog). We only have so many resources available to us which must be factored in (capacity planning). Once we’ve determined what comes next we actually have to plan out the work (sprint planning). Finally we need to track our progress against the plan and make adjustments as we go (managing tasks). With Visual Studio vNext we have introduced a new web based interface that implements the scrum model providing solutions for all of these issues. Because the solution is built on TFS, the data is easily accessed in your favorite tool of choice. You can see some examples here:

Lightweight Requirements
How often have you built exactly what the customer asked for but not what they wanted? In general customers are working hard to provide their requests and the engineering team is working equally hard to make them happy. At the same time there are a lot of steps involved and each point can introduce the potential to diverge between the stakedholder and the engineering team. Visual Studio vNext provides a natural way to work through stakeholder feedback using something we are all familiar with, PowerPoint. Using the Storyboarding plug-in for PowerPoint the product owner can quickly mock up the solution and get feedback directly from the customer before impelmentation begins. Because the solution leverages PowerPoint, you can show linking between screens in your application, demonstrate user actions (like touch), and easily share your proposal. The following screen shots demonstrate some of these concepts:

Stakeholder Feedback
The longer the time between a user asking for a feature and the team delivering, the more likely we are to see disconnects. Ideally we would get feedback on a regular basis to make sure what is being built is what was asked for. To help with this, Visual Studio vNext introduces a new feedback tool (based on the Test Professional support VS2010) which allows a product owner to use the new features and provide actionable feedback. The tool collects video and audio of the feedback session as well as the action logs (which can be turned into test cases). This kind of rich feedback done in a timely way keeps everyone in sync.

Continuous Testing
Having great unit test coverage is one of the best ways to ensure quality in the final product. With Visual Studio vNext we are enabling you to use your favorite unit testing framework integrated deeply into the IDE. We will support MS Test, xunit, and nunit with vNext. You will also be able to target both .NET and native C++ code. Adding test frameworks is an extensibility point as well so if you don’t see your favorite one listed here, you can easily add it.

Agile Quality Assurance
Once our new software has been finished by the development team we need to do our quality assurance passes. This will include a set of functional tests that can utilize the manual and coded testing features of VS2010. For Visual Studio vNext we also wanted to provide a way for a QA professional to explore the product and look for additional issues. The new Exploratory Testing tool provides a great way to do this. As you explore the product the tool records the entire session (audio and video), the action log of steps taken, etc. From the tool you can create a new test case, bug, take snapshots, and take detailed notes. The filtering tool also allows you to select the steps that led to finding a defect. All of these are examples of providing actionable feedback.

System Center and Visual Studio Team Foundation Server 2010

The relationship between the application development and the IT operations teams is critical. We’ve just released a CTP of the new connector between System Center and Visual Studio Team Foundation Server (TFS) 2010 that facilitates the alignment between development and operations. The connector enables an operations team to assign application performance monitoring and diagnostic information gathered by System Center to TFS for immediate attention and application incident triage by the engineering team. Using this support, the operations team can easily capture key data (like call stacks) and automatically deliver them to the engineering team (another example of actionable feedback). Microsoft will deliver a CTP of the new connector later today. Be sure to check it out and let us know what you think!

Find Out More

The “Visual Studio vNext: Application Lifecycle Management” whitepaper is available today. This is a comprehensive whitepaper that covers these topics in much more detail. I recommend you check it out, along with the Visual Studio Roadmap.

The best way to take advantage of the benefits of ALM is to start using Visual Studio 2010 today and obtain an MSDN subscription. Additional helpful links to get you started can be found on our websites:

Visual Studio website – product information
Visual Studio Dev Center – technical and community information

A video of my keynote will be available later on the Teched North America site:

Check out Cameron Skinner, Brian Harry, and Amit Chatterjee’s blogs over the next couple of months for more details on ALM in Visual Studio vNext.

Enjoy!

April 19th What's Happening Around Visual Studio

Jason Zander — Tue, 19 Apr 2011 21:40:00 GMT

It's been a while since I've done a look back on what's been happening on the team. I thought this time around I'd surface up the latest posts regarding our March release of the Visual Studio 2010 Service Pack 1 (SP1).

Installing Visual Studio 2010 RTM and Service Pack 1 Together - Heath Stewart published a comprehensive guide for administrators and developers who may want to install both RTM and SP1 together seamlessly.
Installing Visual Studio 2010 Service Pack 1 May Prompt for Source - Heath also posted a work around for users running into prompts for source during their install.
Visual Studio Library Updates - Our Visual Studio ALM Developer Content Team published a collection of updated documentation for Service Pack 1.
New Local Help Viewer Available in Visual Studio 2010 SP1- Jeff Braaten has a series of posts related to our new Local Help Viewer.
Test and Lab Management Changes in Visual Studio Service Pack 1 Release- Check out Amit Chatterjee's posts regarding the changes made in SP1 for Test and Lab Management. His SP1 Beta 1 post has the majority of the changes listed that you can reference.
Team Explorer 2010 SP1 Bug Viewing Build Summary - The team made a performance improvement for viewing build information from the build explorer as a late breaking change in SP1. Unfortunately, this resulted in a bug when using Team Explorer 2010 SP1 against a TFS 2008 TFS server. A hotfix was immediately released for the issue that you can download if you run into this issue.
Visual Studio 2010 Service Pack 1 Setup Switches - A quick tip on taking advantage of some of the setup switches that are available in SP1.
Visual Studio 2010 SP1 / Updated Report Viewer Redistributable - Brian Hartman published a list of fixes made to the Report Viewer that touched on the most common and visible issues reported by our customers.
Async CTP (SP1 Refresh)- The team recently released an updated version of the Async CTP that's compatible with Visual Studio 2010 SP1 and Windows Phone 7.
Visual Studio LightSwitch Beta 2 - The team recently released LightSwitch Beta 2 that requires Visual Studio 2010 SP1.

If you haven't had the chance to download Service Pack 1, you can find a list of available downloads on our Visual Studio Service Pack web page.

Enjoy!

Follow me at twitter.com/jlzander.

Announcing Microsoft® Visual Studio® LightSwitch™ Beta 2

Jason Zander — Tue, 15 Mar 2011 17:00:00 GMT

I’m happy to announce that as of 10:00 AM PDT today Microsoft® Visual Studio® LightSwitch™ Beta 2 is available for download! MSDN subscribers using Visual Studio 2010 can download the beta immediately with general availability on Thursday, March 17.

Download LightSwitch Beta 2 (MSDN Subscribers with Visual Studio 2010)
Thursday's 10:00 AM PDT general availability download will be here.

Please see “What’s New in Beta 2” for information on new capabilities, installation options, and compatibility notes for this release. Unfortunately, due to the many improvements in Beta 2, projects created in Beta 1 cannot be opened or upgraded. You can find instructions for moving your existing projects forward on the LightSwitch team blog.

We are happy to announce that Beta 2 comes with a “Go Live” license which means you can now start using Visual Studio LightSwitch for production projects!

Since the launch of Beta 1, the team has been heads down in working through your feedback and has made some improvements that I think you’ll agree are pretty cool.

Publish to Azure: the Publish Wizard now provides the ability to publish a LightSwitch desktop or browser application to Windows Azure, including the application’s database to SQL Azure. The team is planning a detailed tutorial of this experience that will get posted on the team blog later this week.
Improved runtime and design-time performance: Build times are 50% faster in Beta 2 and we have made the build management smarter to improve iterative F5 scenarios by up to 70%. LightSwitch Beta 2 applications will startup up to 30% faster than Beta 1. New features like static spans will include related data in a single query execution and improve the time to load data on a screen by reducing the total number of server round-trips. The middle tier data load/save pipeline has been optimized to improve throughput by up to 60%.
Runtime UI improvements: Auto-complete box, better keyboard navigation, and improved end-user experience for long-running operations.
Allow any authenticated Window user: When Windows authorization was selected in a LightSwitch app, you previously needed to add the Windows users who are allowed to use the application into the User Administration screen of the running application. This is cumbersome in installations where there are a large number of Windows users and when you just wanted to open the app up to all Windows users. The project properties UI now allows you to authenticate any Windows user in a LightSwitch application while still using the LightSwitch authorization subsystem for determining user permissions for specific users.

LightSwitch Architectural Overview

Applications you build with LightSwitch follow n-tier best practices and use common .NET technologies that you are probably building upon yourself today. For an overview of LightSwitch architecture, please see "The Anatomy of a LightSwitch Application Series" on the team blog.

I've included a detailed walk through below, to help you get your first LightSwitch application up and running using Beta 2. You may also find the following links useful as you explore LightSwitch:

Now on to building your first application!

Tutorial

In this tutorial we are going to build a student-course registration application to be used at a local college. There are six parts to this tutorial.

Part 1 – Installation
Part 2 – Creating a New Project
Part 3 – Starting with Data
Part 4 – Creating Screens
Part 5 – Adding Relationships
Part 6 – Writing Some Code
Summary

Let’s get going!

Part 1 – Installation

Visual Studio 2010 Professional, Premium, Test Professional or Ultimate users must install Visual Studio 2010 SP1 before installing Visual Studio LightSwitch Beta 2. Visual Studio LightSwitch Beta 1 users should uninstall Beta 1 before installing Beta 2. Also see the Beta 2 readme for late breaking issues. For information on known incompatible releases with Visual Studio LightSwitch Beta 2, please check out the team post.

There are two installation options available from the download link above, a web installer and a DVD ISO image:

Visual Studio LightSwitch, Beta 2 (x86) – DVD (English). This is an ISO image which can be burned to a disc and used by multiple users (or mounted using a utility).
Visual Studio LightSwitch, Web Install Beta 2 (x86) – (English). This is a web installer that will download all components incrementally and install them on a single machine.

Unless you plan to take the bits with you or hand around a DVD to co-workers, I recommend using the web installer which will lower your bandwidth requirements and eliminate the need to burn a DVD or mount an ISO.

A goal of LightSwitch is to remove the need for configuration, so all you have to do is click “Install Now” to get going. After all components are installed, you can simply click the [Launch] button:

Note: if you had Visual Studio 2010 already installed, you will find the new LightSwitch templates in your installation.

Part 2 – Creating a New Project

In this example, I am building a simple course registration application for the staff at the Office of Registrar of a local college. This application will allow the staff to easily register courses for new or existing students.

To get started, choose File, New Project. If you installed Visual Studio 2010, you will need to select the LightSwitch templates:

You can choose from Visual Basic or C#. I’m going to pick Visual Basic and call the application “LightSwitchDemo.” Then hit [OK]. After a few moments your new project will come up and we can start adding data.

Part 3 - Starting with Data

To get started we need to track students. Because working with data is such a basic operation, the initial designer gives you these options right away. We’ll get started by clicking on [Create new table].

This will bring up the table designer. Start by changing the name of the table to “Student”, which you can do by simply typing in the title bar.

Next, edit the fields for the table to store typical data about a student. Note the usage of domain types like Email Address and Phone Number, which provide built-in validation logic and customizable UI on the screens we create in later steps.

To ensure each student record will have a unique email address- click Select Email field and check the “Include in Unique Index” in Properties. This is a new Beta 2 feature.

Next we will need a table for courses. To get started, click “New Table” button in the command bar.

Edit the table name to “Course” and add new columns.

At this point we need to create some UI for our application to allow us to edit table data.

Part 4 - Creating Screens

The most common activities for business applications are layout out your data and create screens to work with that data. In this step we will create a couple of screens to allow us to edit the table data. To start, right click the Screens folder in the Solution Explorer and choose "Add Screen".

There are a very common set of screen patterns for working with data and LightSwitch includes those patterns by default. Screen templates are also an extensibility option for LightSwitch, so you should expect Visual Studio partners to add new patterns in the future (or you can create your own with Visual Studio Professional).

For our application let’s create a “New Data Screen” so we can edit our student list. On the Add New Screen dialog, select “New Data Screen”, then select "Student" from the Screen Data combo box:

Notice that as you select the Student table, the default Screen Name updates itself to give you a reasonable unique screen name. You can always choose to update this name yourself, if you have your own naming pattern to follow. Once you have made the changes, click [OK].

The Screen Designer now appears. For now, let’s just add another screen for the Course table. Again, right click the Screens folder in the Solution Explorer and choose "Add Screen". On the Add New Screen dialog, select “New Data Screen”, then select "Course" from the Screen Data combo box:

Click [OK]. Then hit F5 (or Debug, Start Debugging from the menu). This will kick off a build of the application and start the running app:

By default your application will be a Windows desktop application. If you have experimented with Beta 1, you will notice that Beta 2 has improved the application start time and performance. The default Office-like theme is more refined and user-friendly. It also provides a better use of the screen real estate. You can now collapse both the task list and the ribbon. In Beta 2, we also set the display name of a field based on camel casing convention. For example, FirstName of the Student table will have “First Name” as its display name by default.

The application shell is another extension option for LightSwitch and we have Visual Studio partners working on creating new ones. This means in the future you’ll be able to select from a set of shells to build an application that looks cool (kind of like selecting PowerPoint slide deck templates).

I’ll start by adding my personal information to the database. When done, just click the "Save" ribbon button.

Go ahead and add a few more student and course records.

The two screens make it easy to create new data, but they’re not designed to browse and find existing records. Let’s add a screen to search for students. Close the running application to exit debug mode and return to the Visual Studio IDE. Right click the Screens folder in Solution Explorer and choose "Add Screen".

Select the “Search Data Screen” template and then select the “Students” table from Screen Data combo box, and then hit [OK]. Once again the screen designer will appear. Let’s just hit F5 again.

When you select “Search Student” from the task list, you will get the list of all the student data you have entered. Because we picked the Search template, we have searching, sorting, and paging capabilities built into the screen by default.

Another default feature of the desktop application is Office integration. In this case, I can click on the Excel icon and get my data opened as an Excel spreadsheet.

Notice that First Name is shown as a link, by default. The link takes you to an auto generated details screen for the student. We will show you how to customize the details screen in a bit. For now, I’d like to customize the search column order and make Last Name appear as a link as well. To do this, click “Design Screen” button in the upper right hand corner of the running app to enter the runtime screen designer.

One of the features of LightSwitch is that it allows you to make quick UI changes while the app is running in debug mode. As you change the UI tree, you get an instant preview of what your screen will look like.

Select "Last Name" under Data Grid Row and check “Show as link” in Properties (which is new in Beta 2). You will see the links show up in the preview pane.

Let’s also move the "Last Name" column before the "First Name" column by using the up arrow in the command bar.

Hit [Save]

We have now exited the runtime designer and returned to the running screen. We can see our UI changes reflected in the running app.

As a side note, if the app user resizes the grid columns, LightSwitch will remember the user setting next time he/she runs the app again. This is also something we introduced in Beta 2.

So far my application is looking pretty decent and LightSwitch is doing all the work for me. One unfortunate behavior we have to deal with is that by default our app opens the Create New Student screen every time we launch the application. The college staff won’t be creating a student that often so let’s customize that.

Close the running app and return to the Visual Studio IDE. Double-click the Properties node that’s just under the application node in the Solution Explorer.

On the property designer page, select "Screen Navigation" which will allow us to edit the menu structure for the application.

We want to make the Search Student the default start screen which will avoid trying to add a new record every time we execute the application. To do this, select the "Search Student" task then click [Set] button to make it the startup screen. Let’s also move it up in the task list by clicking the up arrow. When you are done, the designer should look like the following:

Now when we run the application, the student list comes up first and we do not get a new student screen unless we explicitly click on that task.

Part 5 - Adding Relationships

At this point, we have a Student and Course table but we have no way to connect them. Each student can register many courses; and each course can have many students in it. This is a classic many to many relationship which will require a new table to track instances of student-course pairs. Once again we will right click the "Data Sources" folder and choose "Add Table":

Name the table “Enrollment” by editing the title.

Next we need to add a relationship to the Student table. Click the “+ Relationship…” tool bar button.

Using the Add New Relationship dialog is one of those things that remind me why I like LightSwitch so much: it’s just easier to use than other complicated dialogue boxes. When the dialog comes up, simply change the To column of the Name row to our target table "Student".

Notice that the dialog now shows you both the relational diagram of many to 1, as well as plain, old fashioned text to explain what you just did. Having worked on two databases and three database API sets I know how to edit this stuff by hand using SQL syntax, but this is just easier. After your edits are complete, hit the [OK] button to save the relationship. LightSwitch now automatically adds a new column for the relationship and updates the Student table for the foreign key:

Let’s repeat the step again for the Course table by clicking the + Relationship… toolbar button. Now change the target Name to Course to establish the relationship:

Now click [OK] and our many-to-many relationship has been set up through the Enrollment table.

If you double click the Student table item on the designer your focus will change to that table and you can see that the Enrollment column which has been added for you.

Now let’s add a screen for the Enrollment table. As we did before, right click the Screens folder and add a new screen. Select the New Data Screen template and change the Screen Data to the table Enrollment.

Let’s name the screen RegisterCourse, then click [OK].

After the screen is created, hit F5 to run the application. Click the Register Course on the task list to open the screen. We will see an auto-complete box for Student and one for Course.

Auto-complete box is another new Beta 2 feature that LightSwitch provides by default. It greatly improves the keyboard navigation experience for data entry tasks.

We now have a functional application without writing a single line of code! We can create new students, search existing students, and register courses for students. To further optimize the workflow- imagine handling a phone call for an existing student. We’d want to enable a user to find the student via the Search Student screen. Wouldn’t it be nice if we could open the Register Course screen with the student auto complete box already filled out?

Part 6 - Writing Some Code

To do this, we need to provide the Register Course screen with an optional screen parameter. If the parameter is set, we could use it to prefill the student information.

Close the running application and go back to the Visual Studio IDE. Double click on the RegisterCourse screen on the Solution Explorer to open the screen designer. To add a parameter to this screen, click “Add Data Item… “ button in the command bar.

In the Add Data Item dialog, select Local Property, Integer type, and uncheck “Is Required” to make it an optional property. Name the property StudentId and click [OK].

Then select the newly created StudentId in the Screen Designer.

Check “Is Parameter” in the property pane indicating this is a screen parameter.

We now have an optional screen parameter. Next, we need to write some code to check its value when the screen is being initialized. Use the “Write Code” dropdown button in the command bar and select RegisterCourse_InitializeDataWorkspace.

LightSwitch now takes you to the code editor for the Register Course screen:

Private Sub RegisterCourse_InitializeDataWorkspace(saveChangesTo As System.Collections.Generic.List(Of Microsoft.LightSwitch.IDataService))

' Write your code here.

Me.EnrollmentProperty = New Enrollment()

End Sub

InitializeDataWorkspace is called before the data on the screen is being loaded. We want to check for its value and find the corresponding student record. Let’s add the following code:

Private Sub RegisterCourse_InitializeDataWorkspace(saveChangesTo As System.Collections.Generic.List(Of Microsoft.LightSwitch.IDataService))

' Write your code here.

Me.EnrollmentProperty = New Enrollment()

' MY CODE: StudentId is an optional parameter. Check if it has a value. If so, run a query to fetch the student record and prefill the EnrollmentProperty

If (StudentId.HasValue) Then

Me.EnrollmentProperty.Student = DataWorkspace.ApplicationData.Students_Single(StudentId)

End If

End Sub

That’s all we need to do for the Register Course screen. Next, we need to customize the student details screen to include a launch point that opens the Register Course screen with a parameter.

To do this let’s create a details screen for the students. Once again right click the Screens folder and choose Add Screen. Select the Details Screen template and then select the Student table from the Screen Data.

Make sure “Use as Default Details Screen” is checked and click [OK]. The screen designer for the details screen appears.

Let’s add a new ribbon button to the student details screen. Right click on the Screen Command Bar in the content tree and select “Add Button…”

In the Add Button dialog, name the method RegisterCourse and click [OK].

With the newly created button selected, go to Properties and click “Choose Image…” link.

In the Select Image dialog, import an image from your computer for this ribbon button and click [OK].

Double clicking on the Register Course button will take us to the corresponding screen code. Add the following code:

Private Sub RegisterCourse_Execute()

' MY CODE: open the Register Course screen with the student id as its screen parameter

Application.ShowRegisterCourse(Student.Id)

End Sub

Now hit F5 and see it in action. In the "Search Students" screen, click on one of the student links.

It will take us to the details screen we just created. As you can see, we’ve added a new ribbon button called “Register Course.”

Now click on the “Register Course” ribbon button. It will take us to the Register Course screen with the student field already pre-set to Jason. To register a course, you only need to select a course from the auto-complete box and save the screen.

Summary

In this tutorial we’ve created our first working LightSwitch application completely from scratch. We took advantage of some of Beta 2’s new features, along with adding some simple coding. The team is publishing additional walkthroughs that will go into more detail, as well as, providing guidance on publishing to Azure.

With the addition of the Go Live license for Beta 2, you can see we are well on our way towards releasing the final version of LightSwitch. We are really looking forward to your feedback on Beta 2 which will help us get over the finish line.

Enjoy!

Announcing Visual Studio 2010 Service Pack 1

Jason Zander — Tue, 08 Mar 2011 18:00:00 GMT

I’m happy to announce that as of 10:00 AM PST the final version of the Visual Studio 2010 Service Pack 1 (SP1) is available for download! MSDN subscribers can download the bits immediately with general availability on Thursday, March 10.

Download Service Pack 1 (MSDN Subscribers)
Thursday's general availability download is here.

As described with the SP1 Beta post, in this release we have addressed some of the most requested features from customers of Visual Studio 2010 like better help support, IntelliTrace support for 64bit and SharePoint, and included Silverlight 4 Tools in the box. We also added unit testing support on .NET 3.5 and a new performance wizard for Silverlight, among other changes.

We concentrated heavily on fixing issues you reported, including the top voted issues from Connect. The full list of changes can be found in the Visual Studio and Team Foundation Server knowledge base articles. You can also find information about SP1 compatibility, SP1 Readme, and general information about SP1 in the Visual Studio Dev Center.

Today we also announced the immediate availability of two new feature packs for MSDN Subscribers:

Team Foundation Server Project Server Integration Feature Pack – Integration between Project Server and Team Foundation Server is a considerable advancement for organizations that want to bridge the collaboration gap between the Project Management Office and software development teams.
Visual Studio 2010 Load Test Feature Pack – Enables web performance and stress testing throughout the application lifecycle with unlimited virtual users.

Since the launch of Visual Studio 2010 and the .NET Framework 4, we have continued our momentum of focusing on improving the developer experience. Thanks to all of you who have provided feedback along the way.

I hope you enjoy these releases!

Jason

Performance Troubleshooting Article and VS2010 SP1 Change

Jason Zander — Thu, 03 Mar 2011 16:52:00 GMT

We are getting very near to the final release of VS2010 SP1 (if we were landing a plane the wheels would be down right now with the runway in front of us). Thanks again for all your feedback and stay tuned for the imminent release of the product.

We’ve concentrated heavily on fixing issues you have reported, including those related to performance and reliability. The team has collected the most common scenarios we see that may cause issues and published it here:

Visual Studio Troubleshooting

One of the interesting patterns we have seen is that Windows XP users are twice as likely to hit hardware graphics related issues than those using Vista, Windows 7 or Windows Server. In some cases users report slower performance of VS2010 along with the potential for crashing behavior. Very frequently this turns out to be attributable to poor/old video drivers or other operating system components. You can manually turn off hardware acceleration in Visual Studio if you think this is impacting you. To do this, choose Tools, Options and turn off the automatic options:

Based on the number of machine reports we have found with video driver issues, we are taking the step of turning off hardware graphics acceleration in Visual Studio by default for Windows XP users when you install the final version of VS2010 SP1. This change will only impact the Visual Studio IDE, not other applications or your version of Windows. You can also easily turn hardware acceleration back on using the Tools, Options dialog above.

I generally really hate making setting changes like this; as a developer I don’t like it when my environment changes defaults. At the same time I’ve seen enough data about the issues people are hitting today and I want to ensure everyone has a good experience. I’m blogging about this change now to provide the background on the decision as early as possible.

Thanks again for your feedback on VS2010 SP1 and get ready for downloads!

Jason

Visual Studio Jobs

Jason Zander — Tue, 15 Feb 2011 16:23:00 GMT

Often times when I'm attending conferences I am asked if Visual Studio is hiring. Here are a few links regarding open positions within Visual Studio and some additional related links that I think are helpful for staying connected with the community.

General Microsoft Career Links

If you're interested in exploring a career with the Visual Studio engineering team, I recommend you check out our open positions.

January 14th What's Happening Around Visual Studio

Jason Zander — Sat, 15 Jan 2011 00:05:00 GMT

Quick recap of what's been happening on the team.

Rangers Highlights of 2010 - Learn more about the Visual Studio ALM Rangers and the 11 Rangers solutions they shipped in 2010. To keep up-to-date, I recommend following their new Twitter feed twitter.com/wpschaub.
Visual Basic Code Examples - Check out all the code samples the VB Team has recently made available. If you see anything missing, be sure to let them know via the VB code wishlist.
Using the Schemas to Edit Work Item Types and Process Templates - Team Foundation schema files are available on Code Gallery. Check out Allen Clark's post to learn more.
Using Customer Controls to Enhance your LightSwitch Application UI - Part 1 - Karol Zadora-Przylecki walks through how you can use custom Silverlight controls to enhance UI of LightSwitch applications.
Parallelism: In the Cloud, Cluster and Client - Check out Amit Chatterjee's post that talks about the trends in Parallelism with a bit of "testing" woven in.
Urban Turtle for Scrum and TFS - Brian Harry continues his series about "TFS as an open platform". Learn more about these 3rd party enhancements in TFS.
VB Core - New Compilation Mode in Visual Studio 2010 SP1 - Learn about this new compiler feature that enables VB to target new platforms that were not previously supported.
Japanese Team Explorer Everywhere SP1 Beta Available - Check out Brian Harry's post to learn more about this recent Japanese release.
Where do I put my Data Code in a LightSwitch Application? - Robert Green walks thorugh an introduction to data-related tasks.
Using MSBuild and Team Foundation Build - The second edition of this popular book was just released.
Standard Template Library Video Lecture Series - Stephan Lavavej produced a ten part series on the general C++ library that has been very popular on Channel 9.

Enjoy!

Follow me at twitter.com/jlzander.

Tutorial: Dynamic Tile Push Notification for Windows Phone 7

Jason Zander — Mon, 03 Jan 2011 19:24:54 GMT

As I mentioned in my last post, I wanted to update my Tip Express application with dynamic tile notifications. The basic idea is very simple: push the user data from the application to the pinned tile on the home page using the background theme the user has chosen (this isn’t exactly a killer feature for this application, but it gives me a good excuse to play with channel notifications).

There is plenty of overview information on the various types of notifications (Raw, Toast, and Tile) so I won’t repeat that here. In my case I care about Tile notifications and will concentrate on that. The concepts themselves are not that complicated but there are a lot of components to keep track of. I found it was helpful to create a one page diagram of the flow:

Now let’s walk through the various components and look at some source code (note that I have borrowed code snippets from some of the links I posted above to create my sample code).

Step 1: Establish a Channel on the Client Device

The first step happens in our application by establishing a channel with the Push Client running on the device using the HttpNotificationChannel class. The most important piece of data from this process is the ChannelUri which will be used to identify the device on the network – all communication back to the phone will require this value. I also found it handy to create a unique Guid for the device which could be used by my service to index each device uniquely (the URI is quite long).

Once the channel is created you will be able to Find it on subsequent execution of your application. With a valid Channel, we’ll save off the ChannelUri and add some event handlers:

        1: public string ChannelName = "MyAppChannel";

       2: public Uri ChannelUri = null;

       3: HttpNotificationChannel Channel = null;

       4:  

       5: // Step 1:  Setup the channel with the push service.  We'll get a URI required for future communications.

       6: private void SetupChannel()

       7: {

       8:     Channel = HttpNotificationChannel.Find(ChannelName);

       9:     if (Channel == null)

      10:     {

      11:         Channel = new HttpNotificationChannel(ChannelName);

      12:         Channel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(Channel_ChannelUriUpdated);

      13:         Channel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(Channel_ErrorOccurred);

      14:         Channel.Open();

      15:     }

      16:     else

      17:     {

      18:         Channel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(Channel_ChannelUriUpdated);

      19:         Channel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(Channel_ErrorOccurred);

      20:         ChannelUriSetup(Channel.ChannelUri);

      21:     }

      22: }

      23:  

      24: private void ChannelUriSetup(Uri uri)

      25: {

      26:     ChannelUri = uri;

      27: }

In my application I want to generate my own background tile (which I will host on my server) and have the Tile bound to that image. We’ll use Channel.BindToShellTile() to accomplish this, passing in my domain name (“http://www.tipexpress.net/”) as the URI collection:

       1: // Step 1 (part 2):  Whenever the Channel Uri is updated, save the content and bind.

       2: void Channel_ChannelUriUpdated(object sender, NotificationChannelUriEventArgs e)

       3: {

       4:     var uris = GetTileNotificationUris();

       5:     Channel.BindToShellTile(uris);

       6:     ChannelUriSetup(e.ChannelUri);

       7: }

       8:  

       9: private static System.Collections.ObjectModel.Collection<Uri> GetTileNotificationUris()

      10: {

      11: #if PUBLIC_HOST

      12:     string domainPath = "http://www.tipexpress.net/";

      13: #else

      14:     string domainPath = "http://localhost:51046/";

      15: #endif

      16:     var uris = new System.Collections.ObjectModel.Collection<Uri> { new Uri(domainPath) };

      17:     return uris;

      18: }

      19:  

      20:  

      21: void Channel_ErrorOccurred(object sender, NotificationChannelErrorEventArgs e)

      22: {

      23:     Debug.WriteLine("**** Failed channel registration:  " + e.ToString());

      24: }

That’s all we need to do for this step. From this point on as notifications are sent to the device, the Push Client will do the right work for us, including updating the Tile when the application is not running.

Step 2: Register With My Service

Now that our device is ready to go, we need to let our own service know it exists and is interested in updates. This can be accomplished using ordinary web services (WCF, asmx, etc). The key thing required to track and communicate with the device is the ChannelUri from Step 1. Generating a unique Guid on the device can also be a handy way to quickly identify the device on the server (the ChannelUri, while unique, is quite long). You can find sample code for creating a unique Guid and saving it in isolated storage on Jeff Fansler’s blog here.

The goal for my application is to push the totals the user has entered in the application to the Tile pinned on the main page with a background that matches the Accent Theme currently in use. I’ll solve all of this by having a service method as follows:

public void RegisterClientDevice(Guid DeviceId, string ChannelUri, string AccentColor,
string BillAmount, string TipTotal, string TotalAmount)

AccentColor can be found easily through the current application settings as follows:

Color accent = (Color)Application.Current.Resources["PhoneAccentColor"];

string AccentColor = accent.ToString();

This string version of the color can easily be returned into a Color object using ColorTranslator:

Color accent = ColorTranslator.FromHtml(AccentColor);

I now have everything I need to generate the tile. The tile itself must be a PNG with dimensions of 173x173 pixels. So for example if my background is currently set to Green, I would wind up with a tile like this:

The application Title is a field we will set when we do the push and provides us with another piece of customizable data (I’ve included the Tile generation code below if you are interested).

There are various options for designing the server. For my test version I simply indexed the DeviceId Guid into a data structure and generated a local PNG for the tile to the file system. This allowed me to easily return a full URL for the image in the packet. Now that the test system is up and running my next project will be to introduce a SQL database to track everything. My tiles are only 4KB in size and the database approach will make it easier to prune old data, handle locking, etc. I won’t be covering that in this post; just follow standard web server design.

With the tile generated we can move onto the next step, pushing the notification back to the client through the push service.

Step 3: Notify the Microsoft Push Service of Any Interesting Events

Our service is now tracking clients through their ChannelUri and preferences that have been sent directly to us. The job of the service now is to figure out interesting data on some interval and update the client(s). As an example if I were writing an email client, I would want to check for new messages every so often and send out a count of un-fetched mail (as the built-in application does). Weather applications push the current temperature and conditions. Etc. My sample does not really monitor remote data; the goal is to allow the user to have their data on the tile. Given this I want to push the new tile information back immediately after I generate the tile.

I played with many examples while doing this but found the sample code from benwilli to be the easiest to adopt. The code itself is a simple HTTP POST operation with an XML payload describing the tile update. The POST is sent to the ChannelUri created back in Step 1:

HttpWebRequest sendNotificationRequest = (HttpWebRequest)WebRequest.Create(ChannelUri);

For my application I will specify the URL to the background tile and send along the application title (I do not have a count):

notify.SendTileNotification(null, device.UriTilePath, 0, TileTitle);

Ultimately this causes the following (example, formatted by hand for readability) payload to be sent to the Microsoft Push Service:

    "<?xml version=\"1.0\" encoding=\"utf-8\"?>

       <wp:Notification xmlns:wp=\"WPNotification\">

       <wp:Tile>

          <wp:BackgroundImage>http://localhost:51046/UserTiles/005fdf37-d5e4-4497-a4a8-a0252ec8e685.png</wp:BackgroundImage>

          <wp:Count>0</wp:Count>

          <wp:Title>Tip Express</wp:Title>

       </wp:Tile> 

    </wp:Notification>"

The send code will add X-NotificationClass with the value “1” to the header which means the tile update should be sent immediately. My usage case is for people to be able to see the tile update immediately when they start their phone. If my updates were less critical I could use one of the other options which gives the push service the option to do better scheduling.

That’s all for the service code. At this point it will simply register new clients, accept updates, publish new tiles for each user, and push them back.

Step 4: Microsoft Push Service Communicates with Device

The great news about this step is there is nothing for us to do :) The Push Service is provided by Microsoft for free and solves solves two key problems: (1) the service runs at scale world wide making updates more efficient, and (2) your application doesn’t need to be active for the device to receive updates. As updates come into the system, the Push Service will distribute them to the appropriate device which brings us to the last step.

Step 5: Push Client Updates Tiles / Application

There is nothing for us to do on this step either. The Push Client will receive updates and handle them on the device. In my case I bound the tile to the URL which was sent so the Push Client will update the pinned tile to contain that image. If I had registered to receive any notifications directly into my application (and it was running), then the Push Client would also dispatch those updates to my code. This would allow me to funnel data right into my executing application UI.

The final results can be seen by running the application. In the first step I have my application pinned to the home screen with my default (transparent) application icon:

The user then runs the application and enters some data:

In a new “tiles” pivot item I have added, I give the user the ability to save their current data as a tile (I’m not showing all of the permissions related code):

Now after the application exits and the tile updates, you can see the generated tile on the home screen:

Since we give the accent color to the service to generate the tile, it will handle any color currently selected (both the Microsoft built-in themes and any future OEM themes that may be enabled). In this case the phone must communicate with our service so we know the accent color has been updated which means executing the application. If the user changes the color to red then runs the application again with a "Save to Tile” operation, you would get the following:

That’s it!

Errata

I found a few interesting things while working on this code:

Counts – Pushing a Tile notification with <count> specified gives you the small black bubble. Most of the built-in applications such as Messaging and Email have their own custom drawn backgrounds with the count incorporated into them.

I also found that once I pushed a <count> value to the Tile, it would stay resident on the device. The only way I found to remove it was to send the value 0 for the count: “<wp:Count>0</wp:Count>”

Background Tile Restrictions – If you post a background tile, it must be less than 80KB and needs to load in less than 15 seconds (see MSDN reference). The background tile points to a PNG.

Emulator and Channel URI – At least a couple of times I found that my updates to the Push Service would fail with various exceptions (“412 Precondition Failed” for example). I did find that shutting down and restarting the emulator from scratch would fix some of these transient issues (this one deserves more investigation to determine if there is more code required in the client to reset state on the fly).

Tile Generation Code – The actual PNG generation is old school at this point (many web sites use these techniques to generate images on the fly). The trickier part of this sample was getting all of the right data plumbed through the system. Nonetheless, I wanted to provide my sample code in case you are interested in doing something similar:

       1: public class TileBackground

       2: {

       3:     static private float MarginSpacing = 15;

       4:     static private float LineMargin = 5;

       5:     static private int TileDimension = 173;

       6:     static private Single FontSize = 28;

       7:     static private float PenWidth = 2;

       8:     static private Color FontColor = Color.White;

       9:  

    float Spacing = 15;

    float MaxWidth = 0;

    Bitmap objBmpImage = null;

    Font objFont = null;

    SolidBrush brushFont = null;

    Graphics objGraphics = null;

    Pen objPen = null;

  

    ~TileBackground()

    {

        try

        {

            if (objGraphics != null)

            {

                objGraphics.Dispose();

                objPen.Dispose();

                brushFont.Dispose();

                objFont.Dispose();

            }

        }

        catch (Exception e)

        {

            Debug.WriteLine("Failure in ~TileBackground on clenaup: " + e.ToString());

        }

    }

  

    /// <summary>

    /// Generates a tile of the correct dimensions and color with all data included,

    /// then persists the content to a file.

    /// </summary>

    /// <param name="stream">File to save the tile to</param>

    /// <param name="AccentColor">Background color for the tile</param>

    /// <param name="Values">Strings to include in tile</param>

    public void GenerateToFile(System.IO.Stream stream, string AccentColor, string[] Values)

    {

        try

        {

            Bitmap bmp = GenerateBaseLayout(AccentColor, Values);

            SaveToPNG(bmp, stream);

        }

        catch (Exception e)

        {

            System.Diagnostics.Debug.WriteLine("Tile generation failed: ");

            System.Diagnostics.Debug.WriteLine(String.Format("  Path='{0}', AccentColor='{1}', Values='{2}','{3}','{4}'",

                stream, AccentColor, Values[0], Values[1], Values[2]));

            System.Diagnostics.Debug.WriteLine(e.ToString());

        }

    }

  

    /// <summary>

    /// Saves the given bitmap to a stream with high quality encoding.  Sample code

    /// referenced from:  http://stackoverflow.com/questions/41665/bmp-to-jpg-png-in-c

    /// </summary>

    /// <param name="bmp"></param>

    /// <param name="path"></param>

    private void SaveToPNG(Bitmap bmp, System.IO.Stream stream)

    {

        EncoderParameters encoderParameters = new EncoderParameters(1);

        encoderParameters.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 100L);

        bmp.Save(stream, GetEncoder(ImageFormat.Png), encoderParameters);

    }

  

    private static ImageCodecInfo GetEncoder(ImageFormat format)

    {

        ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();

        foreach (ImageCodecInfo codec in codecs)

        {

            if (codec.FormatID == format.Guid)

            {

                return codec;

            }

        }

        return null;

    }

  

  

    /// <summary>

    /// Generate a tile of the correct dimensions and color and then add each line of text

    /// to the tile itself.

    /// </summary>

    /// <param name="AccentColor">Background color for the tile</param>

    /// <param name="Values">Strings to display</param>

    /// <returns>Bitmap image of correct color and data</returns>

    public Bitmap GenerateBaseLayout(string AccentColor, string[] Values)

    {

        if (Values.Length <= 0)

            return null;

  

        // Create the key resources used to render the tile.

        objBmpImage = new Bitmap(TileDimension, TileDimension);

        objFont = new Font("Arial", FontSize, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel);

        brushFont = new SolidBrush(FontColor);

        objPen = new Pen(FontColor, PenWidth);

        objGraphics = Graphics.FromImage(objBmpImage);

  

        // Figure out the height of the font and sizing information.

        float FontHeight = (float)objGraphics.MeasureString(Values[0], objFont).Height;

  

        Spacing = FontHeight * 0.8F;

        float yLocation = MarginSpacing;

  

        // Fill the rectangle to the accent color from the user.

        Color accent = ColorTranslator.FromHtml(AccentColor);

        objGraphics.Clear(accent);

  

        objGraphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

        objGraphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;

  

        // Figure out the length of the longest string for the summary lines and add some extra pixels.

        float [] LineWidth = GetLineWidths(Values);

        MaxWidth = LineWidth.Max() + LineMargin;

  

        // Add each string to the tile placing a single line after the first two and a double

        // line after all the numbers.

        int strNum = 0;

        AddString(ref yLocation, Values[strNum], LineWidth[strNum]);

  

        ++strNum;

        AddString(ref yLocation, Values[strNum], LineWidth[strNum]);

        DrawLine(ref yLocation, MaxWidth);

  

        ++strNum;

        AddString(ref yLocation, Values[strNum], LineWidth[strNum]);

        DrawLine(ref yLocation, MaxWidth);

        DrawLine(ref yLocation, MaxWidth);

  

        // Finalize the image and return.

        objGraphics.Flush();

        return (objBmpImage);

    }

  

    /// <summary>

    /// Get the width of the given strings.

    /// </summary>

    private float[] GetLineWidths(string[] Values)

    {

        float [] rtn = new float[Values.Length];

        for (int i=0; i < Values.Length; i++)

            rtn[i] = (float)objGraphics.MeasureString(Values[i], objFont).Width;

        return (rtn);

    }

  

    /// <summary>

    /// Adds a line of text to the given image and calculates the location for the next line of text.

    /// </summary>

    private void AddString(ref float yLocation, string value, float Width)

    {

        float x = (float)TileDimension - Width - MarginSpacing;

        objGraphics.DrawString(value, objFont, brushFont, x, yLocation);

        yLocation += Spacing;

    }

  

    /// <summary>

    /// Draws a line at the location then adjusts the next location accordingly.

    /// </summary>

    /// <param name="yLocation">Location on y-axis to display line</param>

    /// <param name="Width">Width of the line</param>

    private void DrawLine(ref float yLocation, float Width)

    {

        yLocation += LineMargin;

        float x2 = (float)TileDimension - MarginSpacing;

        float x = x2 - Width;

        objGraphics.DrawLine(objPen, x, yLocation, x2, yLocation);

    }

  

}

More Links – In addition to my last post, here are some additional links that I found helpful while working on my code:

MSDN Instructions for sending a push notification
Wrapper class for notification API’s on the server from benwilli
MSDN Troubleshooting Push Notification Exceptions for Windows Phone

Summary

In summary, the Tile / Notification support in Windows Phone is one of the cool differentiators for the OS from other smart phones so taking advantage of it (and the rest of the “Metro” UI like Panorama and Pivot) are great ways to make your applications more interesting. As I mentioned above, I don’t consider this a “killer feature” for a tip application, it was more for educational purposes. But hopefully you’ve found something helpful in this post if you are working on adding your own tile support. I’m in the process of polishing my own application code now (including making the server more responsive and durable) and will post an updated version of Tip Express to the marketplace soon with the new features outlined here.

Enjoy!

Windows Phone 7 Useful Links for Tile Push Notifications

Jason Zander — Fri, 24 Dec 2010 00:04:56 GMT

I’m on holiday break right now which means it’s time to write some code; I tend to go into withdrawal if I go too long without coding. I’m starting with Windows Phone and moving on to Azure for New Year’s.

I had posted my Tip Calculator application to the marketplace for internal beta purposes, but all the applications were wiped before the phone officially launched. I’ve now posted the final version which you can download to your Windows Phone device, the formal title is “Tip Express” to avoid name collisions. This version uses the pivot control to enable a split check feature (so you can split up the check with other people):

This version also has persistence of the amounts so that when you re-start the application your data is restored automatically.

I’m currently updating the project to allow dynamic Tile support so I can push the data right to the pinned tile of the application. This makes it even easier to use as you can simply enter the data once and if the phone times out, your data will be right on the home screen when the server comes back with your credit card. I think this will be especially handy in Europe where the server brings the remote credit card reader with them to the table and stands over your shoulder as you enter your amount <g>

I’ve come across several decent blog entries and documentation that I thought I’d link to for anyone else looking to do something similar:

Main MSDN overview on Push Notifications
Creating a transparent tile design which matches the theme color from Katrien’s MSDN Blog
Push Notification flow control on codeproject
Jeff Fansler’s “Really Long Post” with sample code
XNA Push Notification sample from MSDN

If anyone has some really great tutorials or samples on the subject, please do post the link. I’m writing up my version for a future post.

Happy Holidays!

Visual Studio 2010 SP1 Interim Fix List

Jason Zander — Mon, 20 Dec 2010 16:00:00 GMT

One of the most common requests from the announcement of VS2010 SP1 was for the list of fixed issues in the release. This is something we typically publish at the final RTM of the release and will do so again for this release. But due to popular demand the team has pulled together a preview of the issues linked from the Connect site that have been fixed so far in the release. One important thing to note is this list is not exhaustive; there are more issues resolved in the release than just those reported through Connect. We’ll have the final list by RTM.

Note that some teams have also published their own more exhaustive list for their areas. Check out Brian Harry’s list for TFS and Amit Chatterjee’s list for the Test products.

C++ runtime

Database

Debugger

Editor

Editor - ASP.NET

Editor - C++

Editor - XAML

Testing

TFS

Miscellaneous

Several posters wondered why we did not have the list already. The main reason is we generally target the final RTM release to do this exercise to ensure we have everything documented (it then shows up as a KB article). We track everything in TFS (as you would expect) so simply running a query is not an issue. As a normal part of a release we track *everything* you could imagine from internal system issues, readme updates, EULA updates, even builds that failed due to the power outage we had 2 weeks ago in Redmond. Clearly these aren’t interesting to publish so the list needs to be scrubbed. Another issue is externally reported bugs often have generic titles like “{Foo} is busted” which is not very descriptive. So we wind up going through the list to try and make it more descriptive and get it down to just the core issues you care about.

I want to say a big THANKS to everyone who has submitted feedback so far on the SP. Your feedback is invaluable to us as we work on finalizing the release and ensuring we have a high quality release. I continue to see a lot of feedback on performance in particular which we would like to correlate with machine configs and project types. If you can send your performance related issues to devperf@microsoft.com we want to do more investigation of the issues. I suspect some OS/machine configs may be the root of the widely varied feedback we’ve received to date. Thanks in advance for your help on this.

Jason

December 16th What's Happening Around Visual Studio

Jason Zander — Fri, 17 Dec 2010 01:20:00 GMT

Quick recap on what's been happening on the team.

Team Foundation Server and Project Server Integration - Learn more about this feature pack released to MSDN subscribers. This integration is a leap forward for organizations that have both Project Management Offices managing many projects and development teams using TFS.
Eurostar 2010 at Copenhagen - Amit Chatterjee recently attended Europe's largest conference for testers. I recommend checking out his post to get an inside look at the conference and how the awareness of our testing tools has increased in the testing industry.
Visual Studio 2010 RTM Virtual Machine - Check out Brian Keller's recent update to the virtual machine that contains the latest feature packs, power tools, and Windows Updates. This VM is a simple way to try out Visual Studio 2010 and Team Foundation Server 2010.
Force VS to Garbage Collect - Cameron Skinner's recent post shows how to force the runtime inside Visual Studio’s address space to collect garbage via a simple keystroke.
How to Create a Many-to-Many Relationship - Check out Andy Kung's walk through of creating a movie database application using Visual Studio LightSwitch.
Visual Studio Library Documentation Updates - Our documentation team recently published additional content for Feature Pack 2 and ALM in the VS Library.
Team Foundation Build Activity Reference - Andy Lewis just released an article that describes in detail the fundamental components of the build process. To learn more, check out Andy's post.
Martin Woodward Brings Team Foundation Server to Everyone - Listen in to .NET Rocks! latest Internet audio talk show with Martin and learn about Team Explorer Everywhere and TFS in general.
Print Your Code in Color - Download this free extension that restores support for printing code in color. To learn more, check out the team's post.
WCF Load Test Tool - The Visual Studio ALM Rangers recently released an update to their WCF Load Test tool.
TFS Ecosystem - Brian Harry recently started a series on TFS and VS ALM as an open platform. If you haven't gotten a chance to check this out, here are the latest posts > Tasktop Announces TFS and VS Support for Mylyn and TeamCompanion and TFS.
ALM Summit 2010 - If you didn't get the chance to attend this year's ALM Summit, I recommend you check the presentations and video recordings. If you're on Facebook, you can also get a good behind-the-scenes look on the ALM Summit page.
The Anatomy of a LightSwitch Application - The LightSwitch team started a series of posts that shed light on "what is LightSwitch really building under the covers?". I recommend you check out this series. Their latest post goes into detail about data access and storage.

Enjoy!

Follow me at twitter.com/jlzander.

Announcing Visual Studio 2010 Service Pack 1 Beta

Jason Zander — Tue, 07 Dec 2010 18:00:00 GMT

I'm happy to announce that the Visual Studio 2010 Service Pack 1 Beta is now ready for download! MSDN subscribers may download the beta immediately with general availability on Thursday. Service Pack 1 Beta comes with a “go live” license which means you can start using the product for production related work (see the license agreement with the product for more details).

Download Service Pack 1 Beta (MSDN Subscribers only)
The link for Thursday's general availability download is here.

Since the launch of Visual Studio 2010 and the .NET Framework 4 earlier this year and our subsequent Feature Packs, we have been concentrating on your feedback and worked hard on the issues you reported through Connect and our survey. I just recently blogged about the results from our recent survey and called out some of the latest improvements the team has delivered.

Service Pack 1 (SP1) continues that momentum of focusing on improving the developer experience by addressing some of the most requested features like better help support, IntelliTrace support for 64bit and SharePoint, and including Silverlight 4 Tools in the box. Some of the additional highlights are:

Help Viewer - The new local Help Viewer is a simple client application that re-introduces key productivity features including a fully-expandable table of contents and a keyword index. For additional information about these improvements, check out Jeff Braaten’s post here.

Better platform support - Looking at support of platforms newly-available around Visual Studio 2010 release, we wanted to make small investments to upgrade our support for them. Silverlight 4 Tools for Visual Studio 2010 (with a few updates to RIA Services) is now included in the box along with Silverlight 3 support, underscoring our commitment to that quickly-evolving platform. We’ve also made a number of other targeted changes, including some additional Win7-specific MFC APIs to support use of Direct2D, DirectWrite, and Windows Animation Technologies. There were also a number of areas where you told us we could do better, so we went in and filled some holes:
- Unit Testing on .NET 3.5 – today all unit tests are run under .NET 4. While acceptable for most users because of the compatibility work we did in .NET 4, this caused problems for some of you with .NET 3.5-specific dependencies.
- IntelliTrace F5 for 64 bit and SharePoint projects – you’ve told us that IntelliTrace is great, but you want to use it on all the projects you’re working on.
- Performance Wizard for Silverlight – Similarly, our performance profiling tools are very useful, but you want to use them for your Silverlight development as well. Silverlight projects are included in the Wizard just like your client projects today.
- VB Compiler runtime switch – This switch will enable Visual Basic developers to target their apps and libraries at platforms where the full Visual Basic Runtime hasn’t traditionally been available.

As an engineering team, the goal for this Service Pack was to work hard on releasing a high quality beta with a focus on only fixing the top-set of important issues we heard about from our customers. Please download the beta and send us your feedback through our Visual Studio Connect site and/or submit your feedback via our Service Pack 1 Beta Survey.

Enjoy!

UPDATE

If you have “ASP.NET MVC 3 RC” installed, please be aware that installing Visual Studio 2010 SP1 Beta will break Razor IntelliSense. There will be a new “ASP.NET MVC 3 RC2” installer released next Monday that you can upgrade to in-place. If you’ve already installed Visual Studio 2010 SP1 Beta, don’t uninstall the Beta Service Pack, just wait until Monday and upgrade your MVC installation.

If you have “Visual Studio Async CTP” installed, please be aware that installing Visual Studio 2010 SP1 Beta will break Visual Studio Async CTP. We are looking at options for an updated release that will make the Visual Studio Async CTP compatible with Visual Studio 2010 SP1. In the meanwhile if you need to work with the CTP you should stick with VS2010 RTM.

Visual Studio 2010 Survey Results

Jason Zander — Sun, 05 Dec 2010 16:00:00 GMT

An important part of our development process for Visual Studio is integrating your feedback. To that end, in October we released a survey collecting your feedback on Visual Studio 2010. We received constructive feedback from over 1,800 respondents. Thanks for taking the time to share with us your comments and improvement suggestions.

The overall results were positive and touched across many areas of the product. We heard from some of you that it is the best IDE out there and that some of the new features such as Call Hierarchy and IntelliTrace are "really awesome"! We also heard from you about areas for improvement including performance. As we have in the past, we will continue to make improvements to Visual Studio based on your feedback.

The team has already delivered on areas in which you have had some concerns. I want to walk you through some of the latest improvements that are currently available for you to download.

Help Viewer Power Tool (Beta) - Since the release of Help Viewer 1.0, the team has been talking with developers and observing the use of Visual Studio help in our usability labs. You can download the Help Viewer Power Tool (Beta) from the VS Gallery. I recommend you check out Jeff Braaten's series of posts that includes a preview of the next set of improvements we're planning to deliver soon.
Insufficient Memory - We heard from customers they were running into issues while attempting to cut or copy small to moderate amounts of text. Downloading this patch will resolve these “insufficient memory” errors. The team also posted additional information about this patch if you'd like to learn more.
Scrolling Context Menu - The team published a couple patches to this widely-reported problem where context menus contain scrollbars even when there is sufficient screen real estate. Information and links to the patches for Visual Studio and Windows Presentation Foundation can be found on the team's blog here.
Find and Replace Dialog - The team released a patch for this top reported bug that fixes the issue with Find and Replace dialog growing 16px on each use.
Color Printing - This extension was created largely in response to your feedback that omitting color printing was causing significant pain on a daily basis. You can download the Color Printing extension from the VS Gallery that addresses that issue. To learn more about the extension, check out the team's blog here.

I encourage you to keep letting us know what you think as you continue to work with Visual Studio 2010. You can engage with us through our Visual Studio forums, team blogs and our Visual Studio Connect site.

Expect to see the next set of improvements coming soon in a future release.

Enjoy!

Announcing: Visual Basic Windows Phone 7 Support RTW

Jason Zander — Mon, 29 Nov 2010 14:45:00 GMT

I’ve personally been enjoying using my Windows Phone 7 device, and it’s been a lot of fun seeing the phones come to market across the world. As a developer, it’s an intriguing opportunity to see so many people buying Windows Phone 7 devices and starting to purchase applications on the Marketplace. With all this excitement around Windows Phone 7, I’m often asked by Visual Basic developers when they’ll be able to submit their applications to the Marketplace. I’m excited to announce that day is here!

Today we’re releasing “Visual Basic for Windows Phone Developer Tools – RTW”. This release is available in the same five languages as the Windows Phone Developer Tools:

English: http://go.microsoft.com/fwlink/?LinkId=206790&clcid=0x409
French: http://go.microsoft.com/fwlink/?LinkID=206790&clcid=0x40c
German: http://go.microsoft.com/fwlink/?LinkID=206790&clcid=0x407
Italian: http://go.microsoft.com/fwlink/?LinkID=206790&clcid=0x410
Spanish: http://go.microsoft.com/fwlink/?LinkID=206790&clcid=0x40a

Please refer to the download pages for a list of System Requirements and Support Statements associated with the release.

To get started with the release, be sure to check out the Visual Basic Code Samples for Windows Phone: http://msdn.microsoft.com/en-us/library/ff431744(VS.92).aspx.

There are also forums available where you can post your questions:

Silverlight for Windows Phone Forum: http://forums.silverlight.net/forums/63.aspx
Windows Phone 7 Development Forum on App Hub: http://forums.create.msdn.com/forums/98.aspx

Walkthrough

To show the experience of building a Silverlight application with Visual Basic for Windows Phone Developer Tools - RTW, lets review a walkthrough highlighting the steps to build my Tip Calculator application in VB. (You can find the complete VB solution posted here.)

First start by installing the System Requirements:

Windows 7 or Windows Vista
Visual Studio 2010 Professional, Premium or Ultimate. If you don’t have one of these releases, you can also install a trial version: Ultimate | Premium | Professional
Windows Phone Developer Tools RTW
Visual Basic for Windows Phone Developer Tools - RTW

When you go to create a New Project, you will see a new Visual Basic project template node under Visual Basic -> Silverlight for Windows Phone. There are 5 Visual Basic Windows Phone project types available, in addition to 16 item templates.

In this case, we select the ‘Windows Phone Application’ template.

(Please note that there are no Visual Basic XNA templates available at this time, since XNA is not currently supported in Visual Basic. This is consistent with the experience in the Visual Basic CTP for Windows Phone Developer Tools.)

Layout

My earlier Tip Calculator post described the process for laying out the application shown below. Please refer to that post for details. The same designer experience is now available for Visual Basic Windows Phone applications.

The application has a built-in numeric key pad for entering the bill amount and controls which allow for adjustment of both the tip percentage, as well as, rounding the total bill to an even number.

In this post, I’ve included Visual Basic versions of the code snippets from my previous post. These code snippets describe how to implement different aspects of the application. For example, below is the code to implement Landscape and Portrait Mode, so that the application layout changes when the user rotates the phone. In order to do this, the application must indicate that it supports the setting and it must handle the change in orientation event as follows:

In MainPage.xaml.vb, add the following line in Sub New():

   1: SupportedOrientations = SupportedPageOrientation.Portrait Or SupportedPageOrientation.Landscape

In MainPage.xaml.vb, update the MainPage_OrientationChanged method to handle the Me.OrientationChanged event:

Private Sub MainPage_OrientationChanged(ByVal sender As Object, ByVal e As OrientationChangedEventArgs) Handles Me.OrientationChanged

...

  

End Sub

When the orientation changes we’ll first move the TotalsGrid into the second column adjacent to the NumbersGrid, then change the column width attributes accordingly:

Private Sub MainPage_OrientationChanged(ByVal sender As Object, ByVal e As OrientationChangedEventArgs)

    ' In landscape mode, the totals grid is moved to the right on the screen

    ' which puts it in row 1, column 1.

    If (e.Orientation And PageOrientation.Landscape) <> 0 Then

        LandscapeColumn.Width = GridLength.Auto

        Grid.SetRow(TotalsGrid, 1)

        Grid.SetColumn(TotalsGrid, 1)

  

        LayoutRoot.ColumnDefinitions(1).Width = GridLength.Auto

        ' In portrait mode, the totals grid goes below the number pad at the

        ' bottom of the screen which is row 0, column 2.

    Else

        LandscapeColumn.Width = New GridLength(0)

        Grid.SetRow(TotalsGrid, 2)

        Grid.SetColumn(TotalsGrid, 0)

  

        LayoutRoot.ColumnDefinitions(1).Width = New GridLength(0)

    End If

End Sub

The resulting display then looks like the following:

Button Handlers

The numeric button grid is implemented in xaml as a 3 x 4 grid. Each numeric button is given a name “button[x]”, corresponding to its value. When a button is pressed, we want to add that new digit to the bill amount. This is perfect place to take advantage of Visual Basic Statement Lambdas feature, introduced in Visual Studio 2010:

Private Sub InitButtonHandlers()

    For i = 0 To 9

        Dim btnName = "button" & i.ToString()

        Dim btn = CType(Me.LayoutRoot.FindName(btnName), System.Windows.Controls.Button)

  

        Dim j = i ' avoid local variable capture

        AddHandler btn.Click, Sub(sender As Object, e As RoutedEventArgs) TryUpdateBillAmount(textBlockBill.Text + j.ToString())

    Next i

Sub

Debugging With the Emulator

Like the C# debugging experience, VB debugging is also very simple - just press F5! By default the emulator is your target:

You can now test the application easily using the normal Visual Studio debugger and emulator controls. For example, to test landscape mode, simply select the direction you want to rotate the device:

Building to Release

Assuming we’re all done developing the application and are ready to submit it to the marketplace, we’ll now change the configuration to Release and Rebuild:

In the Bin\Release folder, you will now find a XAP file, which is the package you will submit to the marketplace.

Publishing the Application

Your best one-stop shop for resources about publishing your application is http://create.msdn.com.

To submit an application to the Windows Phone Marketplace, you’ll first need to register and become a member here: http://create.msdn.com/en-us/home/membership

Here are a few additional resources to review before submitting:

Finally you can use the application submission walkthrough, to guide you through the submission process.

Summary

You can find the full source code for the Visual Basic Tip Calculator application here. The application uses general Silverlight and Visual Basic features, which are available in other application types, and now also apply to the phone. As a VB developer, you’re well-positioned for success creating Windows Phone 7 applications.

Enjoy!

November 5th What's Happening Around Visual Studio

Jason Zander — Sat, 06 Nov 2010 00:15:00 GMT

Quick recap of what's been happening around the team.

Team Explorer Everywhere 2010 SP1 Beta - Download this beta release that comes with a "go-live" license and is available to all Team Explorer Everywhere owners. Check out Brian Harry's announcement post for more details.
Making Asynchronous Programming Easy - Recommend you check out these detailed posts about Async from the teams (What's Next in C#? Get Ready for Async! and Announcing the Async CTP for Visual Basic (and also Iterators!).
The Story of Help in Visual Studio 2010 - Check out Jeff Braaten's blog series that gives a behind-the-scenes look at our help system and a preview of changes that are coming.
TFS on Windows Azure at the PDC - The move to the cloud is gaining momentum. Learn about how the TFS team is making sure your investment in TFS today has a clear path to get you there in the future. You can find additional information about hosting services for TFS on our VS site.
VS ALM Library Updates on MSDN - A new set of documentation was recently published in our VS Library. The team continues to build out these types of updates as a direct result of your feedback.
OData support in Visual Studio LightSwitch - There has been a lot of discussion of whether there is OData support in LightSwitch. Check out the team's post on how to create a RIA service wrapper for OData Source.
More Resources for SharePoint Developers - Check out these how-to videos that demonstrate how to use the SharePoint developer tools in Visual Studio.

Enjoy!

Follow me at twitter.com/jlzander

Tutorial: Pic Viewer Revisited on the Async CTP

Jason Zander — Thu, 28 Oct 2010 18:28:00 GMT

As Soma announced this morning, we’ve just released the Visual Studio Async CTP, a preview of the new language support coming in VB and C# to make it far easier to write responsive client apps and scalable server apps. You can find out more details by visiting the Async CTP site.

For this post, I’m going to continue my Pic Viewer WPF demo from last year, updating it to show what you can do with the Async CTP. If you don’t yet have the Async CTP, you can get it up on the Download Center. Just install it on top of Visual Studio 2010 RTM. The installer will patch your existing compiler and IDE bits and save the old files in case you uninstall.

You’ll also need the starting project. We’ll start mostly from where we left off on the Pic Viewer app last time, with an extra dropdown in place to choose between Internet picture feeds:

The dropdown lets you choose between various BBC News feeds that contain images. The app as written is nifty, but if the network is slow, you’ll notice that it becomes unresponsive each time you request a new feed. This is because WebClient.DownloadString performs the network request synchronously on the UI thread, blocking UI rendering until the request completes:

To keep the UI responsive while waiting for the request, we’ll want to switch to an asynchronous version of DownloadString. The new language support in the Async CTP lets us easily make this transition, keeping our control flow straightforward.

Note that the code samples in this tutorial are written in C#, but the Async CTP also exposes the same feature with identical keywords in Visual Basic.

To start, let’s change our call to wc.DownloadString to instead call wc.DownloadStringTaskAsync, a new asynchronous version of DownloadString that follows the new Task-based asynchronous pattern:

By hovering over the compile error we’ve now introduced, I can see the type mismatch:

While DownloadString returned string, DownloadStringTaskAsync returns Task<string>. Task<T> is a type introduced in .NET 4.0 as part of the Task Parallel Library, and represents an ongoing operation, specifically an operation that will have a value of type T when it completes. By calling an API that returns Task<string>, we’re not receiving back a string, but rather a handle to get a string later, once the network request is completed.

To wait for the network operation to finish while keeping the UI responsive, let’s add the new “await” keyword before our DownloadStringTaskAsync call. Adding “await” gives us a compile error that “await” may only occur in a method with the new “async” modifier, so let’s add that as well:

The “await” expression here tells the compiler to suspend executing the current method and return to the caller. Only when the awaited Task (in this case a Task<string>) completes, producing the string to assign to “text”, is execution of the method resumed. In the meantime, no thread is occupied by this method. The way “await” works behind the scenes is that the compiler schedules “the rest of the LoadFromRss method” as the callback to invoke upon completion.

This is similar to what we’d do manually when calling a traditional async API (such as DownloadStringAsync), but in this case we get to maintain the natural control flow of the try block and the sequence of statements inside. The only difference between our synchronous and asynchronous implementation is two keywords and a call to a different method. Hit F5 and observe that our program now stays responsive while it awaits a reply from the server:

Though our app is now responsive, if you’re observant you’ll notice that each time you change categories you first see one image from the previous category before Prev and Next bring you to the new category. To see why this is, let’s find the method that calls our LoadFromRss method.

To do this, we’ll use Call Hierarchy, a new feature available in Visual Studio 2010 Professional and above. Right-click “LoadFromRss” and choose “View Call Hierarchy” from the context menu.

This brings up the Call Hierarchy pane, letting us easily find all methods that relate to LoadFromRss. From here we expand “Calls To ‘LoadFromRss’”:

Now that we’ve found the caller, Feeds_SelectionChanged, we can double-click it in the list to jump there:

We can now see the problem. LoadFromRss kicks off an asynchronous network request, but since it returns void, we have no way to know when that request completes. Once LoadFromRss “awaits” its network request, it immediately suspends its execution, letting Feeds_SelectionChanged continue. This means that buttonNext_Click gets called before LoadFromRss finishes switching feeds.

What we’d like to do here is “await” LoadFromRss, so that Feeds_SelectionChanged will not continue executing until LoadFromRss is finished with its network request. We start by adding the “await”, along with the “async” modifier the compiler asks us to add:

The compiler then reminds us that we cannot await a method that returns void. We must await a Task or Task<T>, since the compiler must have an object that can signal when the async operation completes.

Therefore, let’s make LoadFromRss return Task instead, a type that signals completion but does not return a value:

It turns out the return type is all we have to change. The compiler knows this is an async method and does the magic necessary to produce a Task that will signal completion when control reaches the end of the method.

If we run the program, we now see that choosing a feed shows an image from that feed right away:

Now that our application loads its data asynchronously and remains responsive, we can easily provide related functionality, such as a progress bar or a Cancel button, which I’ll leave as an exercise to the reader. For more ideas, check out the samples included in the Async CTP under “Visual Studio Async CTP/Async Readme” on the Start Menu.

Enjoy!

New Components and Contributors for IronPython and IronRuby

Jason Zander — Thu, 21 Oct 2010 23:00:00 GMT

The CLR has always been a great environment for dynamic languages and over the last several years we have built out additional dynamic language support for the .NET Framework through efforts like the Dynamic Language Runtime (DLR) and language implementations on top of the DLR. The DLR shipped earlier this year as a built-in component of .NET Framework 4, and we now have several great language implementations built on top of it.

IronPython and IronRuby are two dynamic language implementations that we have incubated internally the last few years. We have released several versions of both language environments (IronPython releases and IronRuby releases), and all of the source code has been released under open source licenses (recently moved to Apache License V2.0).

Today we are announcing new leadership for the Iron projects and a development model that will enable the broader community to contribute to their development:

The community can now make source contributions to any component of IronPython and IronRuby.
For both IronPython and IronRuby, we’ve made changes to the CodePlex projects to allow community members to make contributions without Microsoft's involvement or sponsorship by a Microsoft employee.
We’ve already released the IronPython Tools for Visual Studio that we developed under Apache 2.0. We’ve received great early feedback on the IronPython language service for Visual Studio. Today we are releasing the prototype code for IronRuby Tools for Visual Studio, and we expect similar feedback for IronRuby tools as well. Releasing these components under the Apache 2.0 license allows for community members to use the functionality and also contribute to the IronPython and IronRuby language services.
We have done a lot of ground work for the next version of IronPython v2.7 and IronRuby v1.9.
We have fixed a lot of infrastructure so that the community should be able to regression test all language updates using our tests.
We have enabled a full release work flow to produce builds and releases straight from the CodePlex projects. Previously, these could only easily be done from our own source depots.

As part of these changes I’m happy to announce new project leaders external to Microsoft who will take over the projects and provide leadership going forward. The IronPython project will have Miguel de Icaza, Michael Foord, Jeff Hardy, and Jimmy Schementi as Coordinators. Miguel de Icaza and Jimmy Schementi will be the Coordinators of IronRuby. All of these guys have worked with or on the Iron projects since their inception and I have nothing but trust and respect for the new stewards of these community projects.

Overall, I hope the effect of the changes is to dramatically increase the opportunity for community members to contribute their own code to IronPython and IronRuby, and to actively participate in these projects.

The IronPython and IronRuby projects began as an effort to improve support for dynamic languages in the .NET Framework and to diversify our portfolio of programming languages. These language projects have helped thousands of people since they began, and they have added value to the .NET Framework. They helped create the Dynamic Language Runtime in the .NET Framework 4, on which we have also built C#'s new 'dynamic' keyword and improved Visual Basic's late-binding support. We’ll continue to invest in making the .NET Framework a great runtime environment for dynamic languages going forward.

Working with the community has always been an essential part of developing IronPython and IronRuby, and the feedback and the community review of the source code and specifications has been invaluable. We are looking forward to this new level of involvement from the IronPython and IronRuby communities, and think it will help advance the languages even further.

October 14th What's Happening Around Visual Studio

Jason Zander — Thu, 14 Oct 2010 19:35:00 GMT

Quick recap of what's been happening around the team.

[UPDATE] Hotfix Available for Scrolling Context Menu - Download the latest patch for Visual Studio and Windows Presentation Foundation that fixes the scrolling context menu. You can also find more details in Brian Harry's post.
Microsoft How-To: Scrum for Everyone - Aaron Bjork recently wrote a great article for the Visual Studio Magazine that talks in detail about running a Scrum project using our VS Scrum 1.0 process template in TFS 2010.
Extension Analyzer V3 - Mynor Ivan Muralles' recent post describes in detail the new features that were added to the Extension Analyzer. This VS 2010 extension helps debug issues with VSIX Components, VS Packages, PkgDef Files and MEF Components.
How Do I: Import and Export Data to/from a CSV file - Dan Seefeldt provides a detailed example for using LightSwitch's weakly-typed data access API's that allow you to add general purpose code to perform common tasks.
patterns & practices Symposium (Oct. 18 - 22) - Next week's Symposium is a great way to learn proven practices and technologies to create Web, Mobile, Cloud and Windows solutions.
Do you want better control over code dependencies? - Esther Fan talks about two ways for how to approach this using VS 2010 Ultimate.
Team Foundation Server 2010 Monitoring Management Pack - This week the VS ALM Rangers announced the availability of this management pack that provides both proactive and reactive monitoring of TFS 2010.
How Do I: Set up Security to Control User Access to Parts of a Visual Studio LightSwitch Application - the LightSwitch team just released another great video for learning how to control user access in a LightSwitch application.

Enjoy!

Follow me at twitter.com/jlzander