1. Please follow the article from IIS team to setup IIS 7.0 or above for hosting classic ASP sites.
2. Register any COM and VB6 Dll’s using the regserv32.exe command as shown below: %systemroot%\SysWoW64\regsvr32.exe <path to dll>\<dll name> Or C:\Windows\System32\regsvr32.exe <path to dll>\<dll name>
3. Once you have the COM and VB6 DLL’s registered move the site to the target Application Pool with 32 Bit Application hosting enabled for the Application Pool hosting the site as shown below.
4. Make any modifications such as updating connection strings, drivers if required to get the site working.
5. Test the site and see if the lift and shift was successful.

1. Use the ASP Migration Asisstant to upgrade classic ASP code to ASP.NET. You will need to run this tool with Code on a Windows XP machine. You can create a Virtual PC VM on Windows 7 with Windows XP. Please see article to setup Windows XP mode on Windows 7.
2. Convert VB6 to VB.NET/C# using migration utilities. Other teams at American Airlines have used the VBUC tool.
3. Though the migration tools will convert the VB6 code to VB.NET/C#, you may have to change the way objects are created and referenced from the ASP.NET pages. Other code changes may be required depending on the application.
4. Make any modifications such as updating connection strings, drivers if required to get the site / application working.
5. We must rebuild the code targeting .NET 4.6.1 after all the migration is complete.
6. Test the site/application and see if everything works successfully.

Before we start you will need to obtain a Bing Maps Key.Please visit https://msdn.microsoft.com/en-us/library/ff428642.aspx to get a Bing Maps Key.

To begin, create an ASP.NET Empty Web Application as shown below.

Add a HTML Page to the project. You can right click on the ExampleGeoLocationBing project in Solution Explorer, click on Add and then click HTML Page as shown below.

Name the page default when requested to “Specify the Name for the Item” as shown below. Click on OK.

You should now see the default.html file created as shown below.

In the HTML document, add the onLoad attribute to the body element which will invoke the initializeGeoLocation function when the web page loads in the browser. In the body element, create a div element with an id “map”. The HTML code can be seen below.

Now add a script element in the head element of the HTML document for the Bing Maps AJAX Control.

<script src="https://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=7.0"></script>

Add a folder called Scripts to the ExampleGeoLocationBing project.

Right click the Scripts folder and add a JavaScript file as shown below.

Name the file GeoLocation when requested to Specify the Name for the Item. Click on OK. You should now see the GeoLocation.js file in the Scripts folder as shown below.

Open the GeoLocation.js file by double clicking on it. Add the code below for the GeoLocation API and the Bing Map API as shown below.

In the above code the initializeGeoLocation function creates the geolocation object by utilizing the navigator.geolocation variable. The geolocation object calls the getCurrentPosition method which determines the current position of the user. To this method we pass in the getPosition function. The getPosition function is passed the position object which contains the coords property. The coords property gets the coordinates object which has the latitude and longitude properties. The latitude and longitude properties get the latitude and longitude in decimal degrees.

The getPosition function also initializes a new instance of the Map class. We pass in the container element (which is the div element with map as its id) and the Bing Map Key as arguments. We initialize a new instance of the Location class, which takes the latitude and longitude as arguments. We then initialize a new instance of the Pushpin class which adds a pushpin on the map. We add the Pushpin to the entities property of the map. This will add a pushpin to the current latitude and longitude coordinates of the user returned by the Location class.

Next, we set the map view using the specified coordinates as the center and the zoom level.

Now, return to the default.html page and add a script element for the GeoLocation.js file to the head element. The code for the HTML page should look as shown below.

Set the default.html page as the start page. To do so, right click on the default.html file and select “Set As Start Page”.

Now press F5 to launch the application in a browser. You should see results similar to the one shown below.

If you wish to add some styling to the HTML content, add a new folder called Styles to the project ExampleGeoLocationBing. Right Click on the ExampleGeoLocationBing project in Solution Explorer, click on Add and then click on New Folder as shown below. Name the folder Styles.

Add a new Style Sheet to the Styles folder called default.css. Right Click on the Styles folder, Click on Add and then select Style Sheet as shown below.

Name the Style Sheet default when requested to “Specify the Name for the Item”. You should now see the default.css Style Sheet in the Styles folder as shown below.

Open the default.css Style Sheet and add the following code to it to center the body of the HTML and set the position, width and height of the div element with id map.

Now press F5 to launch the application in a browser. You should see results similar to the one shown below.

Task 1: Create a Database in Azure

First we will create a database in Windows Azure which will be exposed using the Web API. In this example I am using the SyncDB database and the Products table. You can use this Walkthrough to create the SyncDB database.

Logon to the Windows Azure Portal. After you have logged in you will see the portal as shown below. Click on SQL Databases link on the left menu and then click on New as shown below.

You will see the options below. Select Data Services -> SQL Database -> Quick Create. In the Database Name text box enter SyncDB and then click on Create SQL Database. See the figure below for reference.

Once you have created the new SQL Database you will see SyncDB in the list of databases on the management portal as shown below. Click on the SyncDB database.



When you click on the SyncDB database you will see the screen below. Click on Manage at the bottom of the screen (you might have to click on it multiple times).

This will take you to the SQL Database Management portal login screen. Enter the Database server username and password and click on Log on. This is the username and password you chose when you first created the Database Server.

Once you login to the SQL Database Management portal you will see the screen below. Click on New Query.

Once the New Query window opens enter the SQL code from the Walkthrough (only enter code starting from line USE [SyncDB]  onward) and click Run as shown below.

The SQL Code will execute as shown below.

You can now close the query window. Go back to the Windows Azure Management Portal, click on SQL Databases on the left menu and then click on Servers and then select your database server from the list as shown below.

You will then see the Dashboard for the database server. Click on the Configure option and make sure the Windows Azure Services under allowed services section has Yes selected as shown below. Hence our Web API will be able to connect to the SQL Server.

Task 2: Create an ASP.NET Web API

Before we create a Web API in Azure we need to install the Windows Azure SDK for Visual Studio 2012.

After you have installed the SDK open Visual Studio 2012 and create a new project. From the Installed templates select Windows Azure Cloud Service. In the Name text box type ProductWebAPI and click OK as shown below.

You will then see the New Windows Azure Cloud Service dialog box. Select ASP.NET MVC 4 Web Role and add it to the Windows Azure Cloud Service Solution as shown below.

Then from the New ASP.NET MVC 4 Project Dialog box select Web API template. Click on OK. See the figure below.

Once you click OK, you will see the ProductWebAPI solution with the MvcWebRole1 project. We will modify the Get method in the ValuesController.cs class to get a list of products from our SyncDB database.

Before we modify the C# code, we need to get the connection string to connect to the SyncDB database. To get the connection string go to the Windows Azure Management Portal, click on the SQL Databases and click on the SyncDB database as shown below.

Click on Dashboard and click on Show connection strings on the bottom right.

When you see the Connection Strings select the ADO.NET connection string as shown below. Replace {your_password_here} with the Server Password.



Before we modify the Get method add the following namespaces to the code.
using System.Data;
using System.Data.SqlClient;

The modified Get method is shown below.

Task 3: Deploy the Web API to the Cloud

Since we have created the Web API we will now deploy the Web API to the cloud. In order to do so we will first create a new Cloud Service. Go back to the Windows Azure Management Portal and click on Cloud Services from the left menu. Then click on Create a Cloud Service as shown below.

You will then see the screen below. I have named my URL productwebapi as shown below. Click on Create Cloud Service.

We can see that the Cloud Service has been created.

We will now package our Web API and then upload it to the productwebapi cloud service.

Lets go back to Visual Studio 2012, right click on ProductWebAPI Project and click on Package as shown below.

When you see the Package Windows Azure Application dialog box, click Package.

The packaged files are now available on my computer at the location shown below (please note the location). We can see the package and configuration files.

We now go back to the Windows Azure Management Portal, click on Cloud Services and then select the productswebapi cloud service. We then click on Upload a New Production Deployment as shown below.

Enter the Deployment Label, the Package and the Configuration files (these were created and stored locally on the computer and we noted the location). Click on the check to complete the upload as shown.

It will take a few minutes to complete the deployment. Till then you will see screen below.

Once the deployment is complete you will see the screen below. Our site URL is https://productwebapi.cloudapp.net/.

We can access the Get method from a browser by appending api/values to the end of the link. When we go to the link https://productwebapi.cloudapp.net/api/values we will be prompted to save or open the file containing JSON data.

Task 4: Create a Windows Store App using HTML and JavaScript to consume the Web API

Open Visual Studio 2012 and click on the New Project link as shown below.

From the New Project Dialog Box select Templates -> Other Languages -> JavaScipt. In the center pane select Blank App. In the Name text box type productApp and click OK as shown below.

Once you click on OK the new project is created as shown below. Double Click on the default.html file to open it.

In the default.html file replace the code in the <body> section with the code below.

In the productApp project expand the css folder and open the default.css file.

In the default.css file add the CSS rule for the body element as shown below.

Now we need to add the JQuery library to our Solution. Click on the Project menu and select Manage Nuget Packages as shown below.

In the Manage NuGet Packages dialog box search for jQuery in the top right hand side. Then from the middle pane once you see the jQuery library, click on the Install button as shown below.

Once the jQuery library is installed a green check is placed next to the jQuery library in the middle pane as shown below. Close the dialog box.

Now you should see the jQuery files in the Scripts folder in the Solution explorer as shown below.

Go back to the default.html file and drag the jquery-2.0.3.min.js file under the productApp references section as shown below. We will need to use the jQuery library to populate the table body with id productList.

 

Now we go back to the default.js file and add an event handler for the Get Products button. In the default.jsfile after the app.oncheckpoint function, add the buttonGetProductsClickHandler function as shown below.This function uses the WinJS.xhr to consume the Web API and populates the JSON data received from the Web API into the table body with id productList. The url used to call the Web API and get the JSON data is https://productwebapi.cloudapp.net/api/values 

Finally we need to register the buttonGetProductsClickHandler event handler. We register the event handler in the onactivated event handler in default.js, we retrieve getProducts and use addEventListener to register our event handler for the click event. Add this code after the call to WinJS.UI.processAll as shown below.

Now test the application in the Windows 8 Simulator as shown below.

When you click on Get Products button in the simulator you will see the products displayed as shown below.

That's it! We have successfully created a HTML and JavaScript Windows Store Application which consumes a Web API hosted in WIndows Azure using WinJS.xhr.

Microsoft.Synchronization.dll
Microsoft.Synchronization.Data.dll
Microsoft.Synchronization.Data.SqlServer.dll

In this example I am using the SyncDB database and the Products table. You can use this Walkthrough to create the SyncDB database. 

I am also using a DBConnection class which stores and returns my database connection strings.

Now lets discuss the Synchronization. There are two ways to structure your application to synchronize data between SQL Server Database and SQL Azure Database. You could either use 2-tier architecture or N-tier architecture. The difference between the two is as follows:

2 - Tier Architecture - With this option the Sync Framework runs on the local computer and uses a SqlSyncProvider object to connect the SQL Azure database with a SQL Server database.

N – Tier Architecture – With this option the Sync Framework database provider runs in a Windows Azure hosted service and communicates with a proxy provider that runs on the local computer.

In this blog will implement a 2 – Tier Architecture.

To synchronize On-Premise SQL Server database with a SQL Azure database in the cloud we will complete the tasks below.

1. Define the scope based on the tables from the SQL Server database, then provision the SQL Server and SQL Azure databases.
   This will prepare the SQL Server and SQL Azure databases for Synchronization.
2. Synchronize the SQL Server and SQL Azure databases after they have been configured for synchronization as per step 1.
3. Optionally if you wish you can use the SqlSyncDeprovisioning class to deprovision the specified scope and remove all associated synchronization elements from the database.

Task 1: Scope the SQL Server database and then provision SQL Server and SQL Azure databases.

Below are the Sync Framework Classes we will use to scope the SQL Server Database and then provision the SQL Server and SQL Azure databases,

DbSyncScopeDescription - Represents a synchronization scope, which is a logical grouping of tables (optionally filtered) that are synchronized as a unit.

DbSyncTableDescription - Represents the schema of a table that is included in the Tables list of a DbSyncScopeDescription object. This is used during database provisioning.

SqlSyncDescriptionBuilder - Represents scope and table information for a SQL Server database that is involved in synchronization.

SqlSyncScopeProvisioning - Represents the provisioning of a SQL Server database for a particular scope that is represented by a DbSyncScopeDescription object.

We will now write the method to scope and provision the databases.The first thing we will do is to create two SqlConnection objects to connect to the SQL Server and SQL Azure databases as shown below.

// Connection to on premise SQL Server database
   SqlConnection onPremiseConn = new SqlConnection(DBConnection.ConnStringSQLServer);

// Connection to SQL Azure database
   SqlConnection azureConn = new SqlConnection(DBConnection.ConnStringSQLAzure);

We will then use the Sync Framework classes to create scope, choose the tables and choose the columns within the tables and add them to the scope. Below is the code which accomplishes the task.

We create the scope named “product” using the DbSyncScopeDescription class shown below.

DbSyncScopeDescription productScope = new DbSyncScopeDescription("product");

Then we select the columns from the dbo.Products table to be included by adding them to a Collections object. We select the ID, Name and ListPrice columns as shown below.

Collection<string> includeColumns = new Collection<string>();
includeColumns.Add("ID");
includeColumns.Add("Name");
includeColumns.Add("ListPrice");

We then define the schema for the dbo.Products table using the DbSyncTableDescription and SqlSyncDescriptionBuilder classes shown below.

 DbSyncTableDescription productDescription = 
                                         SqlSyncDescriptionBuilder.GetDescriptionForTable("dbo.Products", 
                                                                                             includeColumns, onPremiseConn);

After the schema for the dbo.Products table has been defined we add it to the Tables collection of productScope as shown below.

productScope.Tables.Add(productDescription);

Now we create a SQL Sync Provisioning object using the SqlSyncScopeProvisioning class for the on premise SQL Server as shown below.

 SqlSyncScopeProvisioning onPremiseProvision = new SqlSyncScopeProvisioning(onPremiseConn,
                                                                                                                                       productScope);

We filter rows for the specific ListPrice column and then filter the rows based on the criteria defined below. [side] is an alias for the tracking table.

onPremiseProvision.Tables["dbo.Products"].AddFilterColumn("ListPrice");
onPremiseProvision.Tables["dbo.Products"].FilterClause = "[side].[ListPrice]<'600'";

 if (!onPremiseProvision.ScopeExists("product"))
     onPremiseProvision.Apply();

We create a SQL Sync Provisioning object for the SQL Azure database using the SqlSyncScopeProvisioning class as shown below.

 SqlSyncScopeProvisioning azureProvision = new SqlSyncScopeProvisioning(azureConn,
                                                                                                                       productScope);

Apply the provisioning to the “product” scope if the scope does not exist.

  if (!azureProvision.ScopeExists("product"))
      azureProvision.Apply();

Finally close the SQL Server and SQL Azure database connections as shown below.

 onPremiseConn.Close();

 onPremiseConn.Dispose();

 azureConn.Close();

 azureConn.Dispose();

The complete Setup method for scoping and provisioning is shown below.

public static void Setup()

{
 // Connection to on premise SQL Server database
    SqlConnection onPremiseConn = new SqlConnection(DBConnection.ConnStringSQLServer);

 // Connection to SQL Azure database
    SqlConnection azureConn = new SqlConnection(DBConnection.ConnStringSQLAzure);

 // Create a scope named "product" and add tables to it.
    DbSyncScopeDescription productScope = new DbSyncScopeDescription("product");

 // Select the colums to be included in the Collection Object
    Collection<string> includeColumns = new Collection<string>();
    includeColumns.Add("ID");
    includeColumns.Add("Name");
    includeColumns.Add("ListPrice");

 // Define the Products table.
 DbSyncTableDescription productDescription =
                                         SqlSyncDescriptionBuilder.GetDescriptionForTable("dbo.Products",
                                                                                             includeColumns, onPremiseConn);

 // Add the Table to the scope object.    
    productScope.Tables.Add(productDescription);

 // Create a provisioning object for "product" and apply it to the on-premise database if one does
    not exist.
    SqlSyncScopeProvisioning onPremiseProvision = new SqlSyncScopeProvisioning(onPremiseConn,
                                                                                                                                           productScope);

 // Filter Rows for the ListPrice column
   onPremiseProvision.Tables["dbo.Products"].AddFilterColumn("ListPrice");
   onPremiseProvision.Tables["dbo.Products"].FilterClause = "[side].[ListPrice] < '600'";

        if (!onPremiseProvision.ScopeExists("product"))
           onPremiseProvision.Apply();

 // Provision the SQL Azure database from the on-premise SQL Server database if one does not exist.
   SqlSyncScopeProvisioning azureProvision = new SqlSyncScopeProvisioning(azureConn,
                                                                                                                         productScope);

        if (!azureProvision.ScopeExists("product"))
        azureProvision.Apply();

 // Shut down database connections.

    onPremiseConn.Close();

    onPremiseConn.Dispose();

    azureConn.Close();

    azureConn.Dispose();

 }

Task 2: Synchronize the SQL Server and SQL Azure databases

Now that we have the scope and provisioning complete we will write the method to Synchronize the databases.

We will use the Sync Framework SyncOrchestrator class below.

SyncOrchestrator - Initiates and controls synchronization sessions.

SqlSyncProvider - Represents a synchronization provider that communicates with a SQL Server database and shields other Sync Framework components from the specific implementation of the database.

The first thing we will do is to create  create two SqlConnection objects to connect to the SQL Server and SQL Azure databases as shown below.

// Connection to on premise SQL Server database
   SqlConnection onPremiseConn = new SqlConnection(DBConnection.ConnStringSQLServer);

// Connection to SQL Azure database
   SqlConnection azureConn = new SqlConnection(DBConnection.ConnStringSQLAzure);

We then create the SyncOrchestrator object as shown below.

SyncOrchestrator syncOrchestrator = new SyncOrchestrator();

We then create SqlSyncProviders for SQL Server and SQL Azure as shown below.

SqlSyncProvider onPremiseProvider = new SqlSyncProvider("product"