Tag Archives : Visual Studio 2010

Windows Phone 7 – Development Setup 3


This is the first of a number of articles focused on development for the Windows Phone 7 platform.  I’m in no way new to Windows Mobile development, having suffered through many of the previous Windows Mobile releases.

This time, (sincerity implied) it’s different.  The Windows Phone 7 platform looks to be a universe ahead of Windows Mobile 6.5.  Playing a hasty catch up game, Microsoft has finally released the mobile phone platform we’ve so desired.

Now, getting into the Windows Phone 7 development space was not as simple as installing Visual Studio 2010.  As is common with Microsoft, it involved the download and installation of a plethora of resources.

Initial Preparation

Before we get into the intricacies of building a Windows Phone 7 application, we’ll need to prep the development environment first.  Your baseline development environment should look like this:

  • Windows 7 Professional or Ultimate Edition (32 or 64 bit)
  • or Windows Server 2008 R2 x64 Standard Edition
    • Install IIS with most options enabled (optional)
  • 4 GB RAM (minimum!)
  • 2.x GHz Processor (dual, quad core or better preferred)
  • 512 MB (or better) video card (preferred but not essential)
  • Visual Studio 2010 Premium or Ultimate (full or custom setup) – include SQL Express
  • Visual Studio 2010 Service Pack 1
  • Fully patched (apply all Windows Update patches)

Now after all this has been properly installed (which can take a good evening), you’ll need to go and download the following packages which will be installed on top of the previous.  You could download these whilst building your development environment to speed things up.

Quick Links

Description Link
Windows Phone Developer Tools RTW http://www.microsoft.com/en-us/download/details.aspx?id=13890
Windows Phone Developer Tools RTW ISO Image http://go.microsoft.com/fwlink/?LinkId=201927
Windows Phone Developer Tools January 2011 Update http://www.microsoft.com/en-us/download/details.aspx?id=23854
Windows Phone SDK 7.1 (Web Downloader) http://www.microsoft.com/en-us/download/details.aspx?id=27570
Windows Phone SDK 7.1 (Full ISO Image) http://download.microsoft.com/download/6/E/7/6E795194-EE2D-4636-AEBD-D1C42D2E06E1/WPSDKv71_en1.iso
Windows Phone SDK 7.1.1 Update http://www.microsoft.com/en-us/download/details.aspx?id=29233
Windows Phone 7.5 Training Kit http://www.microsoft.com/en-us/download/details.aspx?id=28564
Windows Phone 7 Training Kit for Developers – RTM Refresh http://www.microsoft.com/en-us/download/details.aspx?id=1678

Developer Tools

10/15/2010 – Windows Phone Developer Tools RTW


If you prefer the full ISO (disk image) rather than using thee “web installer”, use this link:

The Windows Phone Developer Tools includes the following

  • Visual Studio 2010 Express for Windows Phone
  • Windows Phone Emulator Resources
  • Silverlight 4 Tools For Visual Studio
  • XNA Game Studio 4.0
  • Microsoft Expression Blend for Windows Phone

3/3/2011 – Windows Phone Developer Tools January 2011 Update

The Windows Phone Developer Tools January 2011 Update includes:

  • Windows Phone Emulator Update – Exposes copy/paste functionality in the Windows Phone 7 emulator. For more information, see How to: Test Copy and Paste in Windows Phone Emulator. End users can use the copy and paste functionality only after receiving the corresponding update to the Windows Phone 7 operating system.
  • Windows Phone Developer Resources Update – Fixes a text selection bug in pivot and panorama controls. In applications that have pivot or panorama controls that contain text boxes, users can unintentionally change panes when trying to copy text. To prevent this problem, open your application, recompile it, and then resubmit it to the Windows Phone Marketplace.
  • Windows Phone Capability Detection Tool – Detects the phone capabilities used by your application. When you submit your application to Windows Phone Marketplace , Microsoft performs a code analysis to detect the phone capabilities required by your application and then replaces the list of capabilities in the application manifest with the result of this detection process. This tool performs the same detection process and allows you to test your application using the same list of phone capabilities generated during the certification process. For more information, see How to: Use the Capability Detection Tool.
  • Windows Phone Connect Tool – Allows you to connect your phone to a PC when Zune® software is not running and debug applications that use media APIs. For more information, see How to: Use the Connect Tool.
  • Updated Bing Maps Silverlight Control – Includes improvements to gesture performance when using Bing™ Maps Silverlight® Control.

9/25/2011 – Windows Phone SDK 7.1
http://www.microsoft.com/en-us/download/details.aspx?id=27570 (web downloader)
http://download.microsoft.com/download/6/E/7/6E795194-EE2D-4636-AEBD-D1C42D2E06E1/WPSDKv71_en1.iso (full ISO image)

The Windows Phone SDK includes the following:

  • Microsoft Visual Studio 2010 Express for Windows Phone
  • Windows Phone Emulator
  • Windows Phone SDK 7.1 Assemblies
  • Silverlight 4 SDK and DRT
  • Windows Phone SDK 7.1 Extensions for XNA Game Studio 4.0
  • Microsoft Expression Blend SDK for Windows Phone 7
  • Microsoft Expression Blend SDK for Windows Phone OS 7.1
  • WCF Data Services Client for Window Phone
  • Microsoft Advertising SDK for Windows Phone

3/26/2012 – Windows Phone SDK 7.1.1 Update

Windows Phone SDK 7.1.1 Update includes the following

  • New 256-MB version of Windows Phone Emulator
  • Updated 512-MB version Windows Phone Emulator


Training Kits

2/3/2011 – Windows Phone 7 Training Kit for Developers – RTM Refresh


  • Complete Windows Phone Training kit for Developers includes both Silverlight and XNA Framework labs
  • Windows Phone Training Kit for Silverlight Developers includes only Silverlight labs
  • Windows Phone Training Kit for XNA Framework Developers include only XNA Framework labs


12/19/2011 – Windows Phone 7.5 Training Kit


Two sets of hands on labs for Windows Phone 7.5 application development. These are packages that support a full offline installation of the labs that are available live online.


Tools Reference

Windows Phone Developer Tools and Device Unlock


For Reference –

Application Certification Requirements for Windows Phone

App Hub Application Submission Walkthrough

Schema Fun with BizTalk Server 2010 (and more!) 4


As I alluded to at the very end of 2011, I’ve been spending more and more time with BizTalk 2010. It’s been a little while since I’ve had to support/build/maintain BizTalk artefacts, but it doesn’t take long to reacquire “the groove”.

To gently thrust you into the dark underbelly of the land of BizTalk development, I thought I’d start off by exploring some fairly basic BizTalk 101 type experiences (and solutions!).  This article focuses on generic issues with XML schemas, with an eye to BizTalk’s usage of said schema.

Sadly, some of what you might read here (and later) might smack a tad of ‘What?  You didn’t know that?”, but I’m willing to swallow some pride if it helps out other Architects and Programmers.

What you need (to follow along)

This article is (IMHO) decent enough for the generalist (non-BizTalk specialist) and especially may be handy for those unfamiliar in working with XML schemas.

There is a big part where I’m playing with BizTalk’s Developer Tools (in Visual Studio 2010), so if you’d like to give it a go, I’d suggest you pick up a copy of BizTalk Server 2010 Developer Edition (click here for more info on this edition of BizTalk), which – I believe – you need to have to install the developer tools.

If I write subsequent article on BizTalk, the BizTalk developer tools will likely play a significant role, so it might be worth investigating.  As always, it’s worth bookmarking the BizTalk Development Center link.

The Joys of Schema

If you know anything about BizTalk, you’ll know that it’s all about the schemas. Everything ends up mapping to a document schema type whether it’s inbound or outbound. Schemas (XSD) can be an acquired taste, especially if you’ve been off doing something more exciting.

Last month, handwritten schemas tripped me up quite a bit. I was used to using Wizards and Adapters to generate a lot of the schemas for me, so when I went to design some basic input and output schemas, I encountered some “fun” issues.

Something funny happened…

Now, I was putting together some very basic sample schema to use as an example for demonstrating a really neat technique with maps (transforms).

Just in case someone else encounters this (or, like me, found it mildly amusing) I thought I’d document some cause and effect of why you might get some head scratching error messages when designing in Visual Studio 2010 with the BizTalk designer.

Given the following (flawed) schema, which I built within Visual Studio:

<?xml version="1.0" encoding="utf-16"?>

<xs:schema xmlns="http://Sandbox.InputSchema" xmlns:b="http://schemas.microsoft.com/BizTalk/2003" targetNamespace="http://Sandbox.InputSchema" xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="Root">



        <xs:element minOccurs="2" maxOccurs="3" name="Customer">



              <xs:element name="Address">


                  <xs:attribute name="Street" type="xs:string" />

                  <xs:attribute name="State" type="xs:string" />

                  <xs:attribute name="Country" type="xs:string" />




            <xs:attribute name="ID" type="xs:integer" />

            <xs:attribute name="FirstName" type="xs:string" />

            <xs:attribute name="Surname" type="xs:string" />







Which, when loaded in the BizTalk Schema Designer looks like this:


Has an unfortunately obvious flaw if you consider I was expecting the schema to facilitate the following format of XML data:

<ns0:Root xmlns:ns0="http://Sandbox.InputSchema"> 

  <Customer ID="100" FirstName="FirstName_1" Surname="Surname_2">

    <Address Street="12 Jump Street" State="NSW" Country="Australia" />


  <Customer ID="101" FirstName="FirstName_1" Surname="Surname_2">

    <Address Street="22 Fish Street" State="QLD" Country="Australia" />



In other words, I was expecting to store multiple “Customer” elements in my XML document.


When I loaded the document and tested it in Visual Studio 2010, I received the following, very weird error message: “The element ‘Root’ in namespace ‘http://Sandbox.InputSchema’ has invalid child element ‘Customer’.” – huh?


The problem, I thought, might be related to not expressly prefixing the namespace directive to the child element, so I made some edits.

This resulted in an even more ambiguous error message, funny even:

“The element ‘Root’ in namespace ‘http://Sandbox.InputSchema’ has invalid child element ‘Customer’ in namespace ‘http://Sandbox.InputSchema’. List of possible elements expected: ‘Customer’.”

or, in generic terms:

“The element ‘<element>’ in namespace ‘<namespace>’ has invalid child element ‘<child element>’ in namespace ‘<namespace>’. List of possible elements expected: ‘<child element>’.”


You may have to squint to read the text…

At this point, I felt like I was going backwards. So I undid my changes and took a look at the schema definition – which, upon second inspection was clearly wrong.

The Solution

See if you can spot the difference?


My mistake was in not declaring a sequence after the root element. Thus rectified, my XML now matched the fixed schema, and I was able to continue on my merry way.


Filtering in a Transform/Map

This all brings us back to the original intention of my article – to highlight the use of functoids for filtering multiple nodes in a transform.

Given that we want to transform our input schema (from before) into another format, with filtered data, here’s the schema for the output:


The Mapping

We can construct a map which assigns the fields we want per the following example:

A basic map

Now, if we wanted to only take Customers who live in the state of New South Wales, we need to validate each element in the input XML recursively.

A Functoid for all occasions

The easiest means is to use a equality functoid, in this example I’ve used an equals functoid, as per below. You must still map the field directly to the output schema, but also to the functoid – which is, in turn, mapped to the logical root of the target (per the example above).


When the functoid returns a true value, the element is copied to the output. If the result is fale, the entire element (children etc) are skipped. Thus, from the following input XML:

<ns0:Root xmlns:ns0="http://Sandbox.InputSchema"> 

  <Customer ID="100" FirstName="FirstName_1" Surname="Surname_2">

    <Address Street="12 Jump Street" State="NSW" Country="Australia" />


  <Customer ID="101" FirstName="FirstName_1" Surname="Surname_2">

    <Address Street="22 Fish Street" State="QLD" Country="Australia" />



When run through this map (using trusty ‘Test Map’ functionality), will generate the following output, filtering out that pesky Queensland (QLD) customer:

<ns0:Root xmlns:ns0="http://Sandbox.OutputSchema">

  <Address Street="12 Jump Street" State="NSW" Country="Australia" CustomerID="100" />


Helpful Support in Visual Studio 2010

Before you start despairing about schema development and BizTalk maps, there are a bunch of very helpful tools built into Visual Studio 2010 (and prior versions).

Generating Schema Instances

Given you have Schema files in your project, you can right click them and select “Generate Instance”. This will create an XML file using intelligent default values, according to the schema definition. These files can be modified and used to test out other artefacts who use this schema.

Validating Schema Instances

If you want to test if a particular XML file is valid, you can do the reverse – by clicking on the schema properties, you can set the “input XML” for a given schema. Then, when right clicking on the Schema in Solution Explorer, you can select “Validate Instance”. This will highlight any issues with your schema.


Testing a Map/Transform

Once you have some valid XML for your schema, you can then use it as test input data for various things including maps.

The following shows how to establish test data parameters for a map within Visual Studio 2010:


When you have configured a map to use a specified XML input, you can then right click on the map (in Solution Explorer) and select “Test Map”.

Other Options – Xml Schema/Data Type Utility

A handy note for future reference – if you have an XML structure in mind, but (like me) you are rusty with your XSD designing skillz, there’s another way forward which may prove to be better.

There is a tool which helps you work with XML and XSD document formats, and it ships by default with a number of Microsoft products and SDKs, it is called “Xml Schemas/DataTypes support utility” or XSD.exe.

Important Disclaimer: In nearly almost all circumstances, it is considered a better practice to produce or design the XML schema first. Generating a schema from XML data can be fraught with peril, especially if your XML sample doesn’t accurately reflect the full spectrum of supported formats.

For example, min/max occurrences, type lengths and other constraints, vague data types (where the type or precision is “guessed”), elements supported by the schema which are not required – and thus missing from your sample XML – to name but a few.

Where Do I Find This Tool?

Chances are that you have it already. I’ve located it installed in the following locations (check the (x86) folder as well if you are on a 64 bit machine):

Directory of C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin

Directory of C:\Program Files\Microsoft SDKs\Windows\v7.0A\Bin

Directory of C:\Program Files\Microsoft SDKs\Windows\v7.0A\Bin\NETFX 4.0 Tools

Directory of C:\Program Files\Microsoft SDKs\Windows\v7.0A\Bin\x64

What does it do?

Keeping in mind that this utility was really meant for the days of evil DataSets, it still can be quite useful.

Using the following (poor) sample XML structure:

<?xml version=”1.0” encoding=”utf-8”?>
<Country Name="Australia">
     <State Name="NSW">
           <Capital Name="Sydney"/>
     <State Name="QLD">
           <Capital Name="Brisbane"/>
     <State Name="WA">
           <Capital Name="Perth"/>
     <State Name="TAS">
           <Capital Name="Hobart"/>
     <State Name="VIC">
           <Capital Name="Melbourne"/>

You can use the XSD.exe utility to generate an approximation of the schema, like so:

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin>xsd Input.xml

Microsoft (R) Xml Schemas/DataTypes support utility

[Microsoft (R) .NET Framework, Version 2.0.50727.3038]

Copyright (C) Microsoft Corporation. All rights reserved.

Writing file ‘C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\Input.xsd’.

Which would produce the following output:

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

<xs:schema id="NewDataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">

  <xs:element name="Country">



        <xs:element name="State" minOccurs="0" maxOccurs="unbounded">



              <xs:element name="Capital" minOccurs="0" maxOccurs="unbounded">


                  <xs:attribute name="Name" type="xs:string" />




            <xs:attribute name="Name" type="xs:string" />




      <xs:attribute name="Name" type="xs:string" />



  <xs:element name="NewDataSet" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">


      <xs:choice minOccurs="0" maxOccurs="unbounded">

        <xs:element ref="Country" />





Now, given I mentioned that bit about the DataSet support.. You’ll need to remove the element called “NewDataSet”. This is included because the utility assumes you want to generate a schema for use with DataSets.

Removing the element, renders a nice XSD in Visual Studio:


But wait.. There’s more

Given a valid XSD schema, you can now use the same utility (isn’t it wonderful?) to generate valid C# classes by using the following syntax:

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin>xsd Input.xsd /c

Microsoft (R) Xml Schemas/DataTypes support utility

[Microsoft (R) .NET Framework, Version 2.0.50727.3038]

Copyright (C) Microsoft Corporation. All rights reserved.

Writing file ‘C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\Input.cs’.

The result of executing this command produces the following classes (which you could now serialize into and out of XML):



You may not be able to teach a dog new tricks, but I’m willing to bet he remembers a bunch of old ones!

Although I’m a bit rusty, I’m able to overcome obstacles reasonably quickly. This article might not make me look like Einstein, but I thought I’d write up some of my experiences in the hope it helps others.

We’ve only just touched the tip of the iceberg with BizTalk 2010. The development environment is challenging and prickly (which makes for great sources of inspiration for blog articles) so you can be sure there will be more here soon, so check back!

Analyze .NET Applications with Visual Studio 2010 (Part 1)


If you have a copy of Visual Studio 2010 Premium or Ultimate, you’ll likely have a menu in your Integrated Development Environment (IDE) called “Analyze”. 

Chances are, you might not have investigated the true potential of the profiling tools in VS 2010.  This article will demonstrate usage of some of the profiling techniques, and then discuss how to interpret and act on the results.

You’ll need:

  • A copy of Visual Studio 2010 Premium or Ultimate
  • A .NET solution for testing purposes, the more complex the better
    • Preferably a WinForms or Console application, but a WCF service application or ASP.net website will work just fine
  • Memory (at least 4 GB) and a decent CPU

Profiling is an expensive operation in terms of system resources.  Trying to profile a .NET application on a slow, low memory machine is going to be a long and frustrating task, so choose and configure your environment well!

My Environment

At the moment, I’ve configured two independent environments – a desktop machine, and a Hyper-V virtual client OS, specifications are as below.


  • Windows 7 x64 + Service Pack 1
  • Intel Core i5 2400 3.10 GHz (dual core with hyper-threading)
  • 4.0 GB Memory
  • 222 GB HDD (120 GB Free)

Hyper-V Server Client OS

  • Windows Server 2008 R2 x64+ Service Pack 1
  • AMD Opteron (Dual Core) 2216 HE 1.58 GHz
  • 6.0 GB Memory
  • 60 GB HDD (20 GB free)


Profiling is not an inexpensive operation.  You will require a decent amount of hard drive space (so that Visual Studio can record profiling information as you run your tests) and plenty of memory.  Remember, most of the time the focus should be on determining what your application or services does, not so much why it labours when in a resource constrained environment.

I’m not saying that there’s no value in profiling under a resource constrained environment – there likely is – however it will be a terribly frustrating endeavour and it will be hard to differentiate between overhead from running your application or service, and the overhead of the act of profiling itself.  You can likely extrapolate the impact of low resource environments based on the metrics collected during profiling anyway.

In short: the better the environment you profile under, the more likely the data is of use to you.  Just keep it in mind.

In my more recent experience, I found that a memory profile session used almost 8 GB of hard drive space to track/record an application which had a memory footprint of between 500mb to 650 mb.  I’m not sure if this is much of a guide.  The more HDD space the better is a good general rule.


Open your solution in Visual Studio, for best results, I’d recommend profiling in Debug configuration and preferably according to the processor architecture of your machine (i.e. x64 if your machine is 64 bit).  Ensure your solution successfully compiles – always helps – and you should be ready to proceed.  Note – if you are using a processor specific configuration, all modules to be profiled must match (no mix ‘n match of 32 and 64 bit modules).  Assuming you have Visual Studio 2010 Premium or Ultimate, you should have an “Analyze” menu:


The best way to proceed, the first time, is to “Launch Performance Wizard”:


There are quite a few decent options here, but what do they cover?  Here’s a more in depth look at each configuration:

Method Description
Sampling Collects statistical data about the work performed by an application.
Instrumentation Collects detailed timing information about each function call.
Concurrency Collects detailed information about multi-threaded applications.
.NET memory Collects detailed information about .NET memory allocation and garbage collection.
Tier interaction Collects information about synchronous ADO.NET function calls to a SqlServer database.

For this and the next article in this series, I’m mostly going to focus on the more useful profiling methods – .NET Memory and Instrumentation, but concurrency, tier interaction and sampling all have their uses.

What is useful in understanding up front, is that no matter what your method of data collection (profiling) is, the template within which the profile reports are rendered remains more or less the same.  The varying factor is the X-factor – i.e. the “what is collected”.  Memory is pretty obvious – the focus of sampling is on the allocation (exclusive and inclusive) of memory and the performance of Garbage Collection.  With instrumentation, the sampling focus is on call frequency, call chaining, call durations and the distribution of call frequency between functions and modules.

The more information that can be supplied (i.e. symbols, debugging info such as .pdbs and line numbers/source code) the better when it comes to exhaustive analysis.

Some Notes on Running the Profiler

You will almost invariably need to run Visual Studio 2010 with elevated permissions.  This (some days) seems like a universal constant as we start to require a heavier hand in constructing, tuning and testing our software.  For the best results, the more control and permissions you have (administration rights help the profiler collect performance counter stats information, for example) the better.  Some profiling (such as concurrency) may require changes to the system configuration (and may require a system reboot).

In the next article…

That’s it for our introductory article – the next article will dive into the actually profiling itself, and how to interpret the results.  Stay tuned for more.


Further Reading

Compare Editions of Visual Studio 2010

Understanding Profiling Methods

User Permissions Required to Profile (applies to Vista, but should apply equally to Windows 7 and Server 2008)