First things first.!

BLOB storage is part of storage accounts. BLOB storage enables you to store files in the cloud. When you upload a file into a BLOB container, you will start referring to the file as a BLOB and not a file anymore, don’t ask me why . There are two types of BLOBs, Block BLOBs and Page BLOBs. Block BLOBs can sit in one fixed block of a max of 200GB while Page BLOBs can grow up to 1TB and is used mostly when ranges of bytes in a file are frequently updated. Unfortunately you will get a flat container, meaning you can not have folders and sub folders there. Easiest trick in the book to get organized is to include a “/” in the BLOB name e.g. “images/avatar01.png” instead of “avatar1.png”.  Below diagram quickly illustrates the structure where containers sit inside storage accounts and BLOBs would sit inside the containers.

To learn more about Azure BLOB Storage click here.

What are we building today?

Since we have established by now that we won’t have fancy sample applications but instead direct answers in this series, I expect you to go over the previous lesson before continuing. I won’t show you how to create a storage account and get your hands on an access key every post  

In a nutshell, we will build a simple CRUD command line application for an Azure Blob. Checkout the below screenshot of the console application.

The Console Application

Very straight forward, an endless loop displaying the menu and waiting for the user to input. A switch statement is there to trigger the right function based on user input.

Upload a new BLOB

To keep it simple, we will ask the user for the path of a file they would like to upload to the BLOB container. At the main menu, when the user would input 1, they will be directed to the input screen.

At the input screen we will ask them about their file path.

Check out the function’s code below. We simply establish a BLOB client, get a reference to the container, ask the user for the file path and execute the upload activity.

Delete a specific BLOB

From the main menu, the user will input 2 and be directed to the input screen.

At the input screen we will ask the user for the name of the BLOB they would like to delete.

To verify that the Blob was deleted, Browse the Server Explorer to reach the container and list it’s contents. As you can see the Blob03

Check out the function’s code below. We simply establish a BLOB client, get a reference to the container, ask the user for the BLOB name and execute the deletion activity.

List all BLOBs in a Container

From the main menu, the user will input 3 and be directed to the list screen.

At the list screen an output of all the BLOB Uri’s will be displayed.

Check out the function’s code below. We simply establish a BLOB client, get a reference to the container, and finally loop the container BLOBs printing out the Uri.

aaaand we are done with the lesson. Let me know if you have any questions or comments

First things first.!

Azure Storage Tables are part of Storage Accounts. In addition to tables, Storage Accounts host Queues, BLOBs, and Files. So what’s cool about tables? well, if you are looking for a scalable, convenient, and very cost effective solution to store non-relational data with a clustered index. Then you are in the right place. Below diagram quickly illustrates the structure where tables sit inside storage accounts and entities would sit inside the tables.

To learn more about Azure Table Storage click here.

What are we building today?

As you will get used to meaningless examples in this series we will build a simple CRUD command line application for an Azure table. Checkout the below screenshot of the console application:

In addition to the CRUD operations, I will show you how to do a batch insert as well. Don’t get too excited though, according to this link over MSDN: A batch operation may contain up to 100 individual table operations, with the requirement that each operation entity must have same partition key. A batch with a retrieve operation cannot contain any other operations. Note that the total payload of a batch operation is limited to 4MB. I hope this will change in the near future.

Let’s get cracking and create the Storage Account and the Azure Table

Navigate to the Azure portal and start with creating a storage account. I called it “paas101”. Unfortunately, up till now you can not use the Azure portal to manage the tables. You need to use a tool for this. Personally I use Visual Studio. A quick search on Bing will do the trick for you.

Launch Visual Studio and open the Server Explorer. You will find an Azure node. If this is the first time you do this, Visual Studio will ask you to login using your Microsoft Account. Look for your Storage Account, expand it, right click Tables, and create a new table. I called it Lesson02.

Once the table is created, you will notice that by default 3 columns are created: the clustered index aka Partition Key, the Row Key, and an automatically generated Timestamp. Add an additional property and call it “SomeRandomNumber”. Yeah I know

I just added an entity manually, notice the Timestamp being populated automatically in the below screenshot.

Next step would be adding the “Windows Azure Storage” NuGet package to the project:

and now the last step before we start writing code is getting our hands on the access key. Without the access key our client application will not be able to interact with the Storage Account. Navigate to your Storage Account on the Azure portal and click on the Manage Access Keys button on the bottom:

Copy one of the access keys to the clipboard.

Now go back to your command line solution and add a new Class that will represent the entity. For the sake of the demo I called it “SomeEntity” Notice from the code below that it is inheriting from the TableEntity class:

 1 using Microsoft.WindowsAzure.Storage.Table;
 2 
 3 namespace PaaS101.Lesson2
 4 {
 5     public class SomeEntity : TableEntity
 6     {
 7         public string SomeRandomNumber { get; set; }
 8         
 9         public SomeEntity(string entityPartitionKey,
10             string entityRowKey,
11             string someRandomNumber)
12         {
13             PartitionKey = entityPartitionKey;
14             RowKey = entityRowKey;
15             SomeRandomNumber = someRandomNumber;
16         }
17 
18         public SomeEntity() { }
19     }
20 }

The console application

Very straight forward, an endless loop displaying the menu and waiting for the user to input. A switch statement is there to trigger the right function based on user input.

 1         private const string Protocol = "https";
 2         private const string AccountName = "paas101";
 3         private const string AccountKey = "XXXXXX-KEY GOES HERE";
 4         private const string TableName = "Lesson02";
 5         private const string PartitionName = "Lesson02";
 6         private const string Success = "\nOperation completed successfuly. Press any key to go back.";
 7         private const string Fail = "\nSomething went wrong, press any key to go back.";
 8 
 9         private static string _connection;
10 
11         static void Main(string[] args)
12         {
13             _connection = string.Format("DefaultEndpointsProtocol={0};AccountName={1};AccountKey={2}",
14             Protocol, AccountName, AccountKey);
15 
16             Console.TreatControlCAsInput = true;
17             Console.Clear();
18 
19             while (true)
20             {
21                 Console.Clear();
22 
23                 Console.WriteLine("Welcome to Lesson 02, let's play with Table Storage.");
24                 Console.WriteLine("\t1. Insert a new entity");
25                 Console.WriteLine("\t2. Update a specific entity");
26                 Console.WriteLine("\t3. Delete a specific entity");
27                 Console.WriteLine("\t4. Insert a new batch of entities");
28                 Console.WriteLine("\t5. Display all entities");
29                 Console.WriteLine("\t6. Exit");
30 
31                 Console.WriteLine("So what do you want to do?");
32 
33                 int input;
34                 if (!int.TryParse(Console.ReadKey().KeyChar.ToString(), out input)) return;
35 
36                 switch (input)
37                 {
38                     case 1:
39                         InsertNewEntity();
40                         break;
41                     case 2:
42                         UpdateSpecificEntity();
43                         break;
44                     case 3:
45                         DeleteSpecificEntity();
46                         break;
47                     case 4:
48                         InsertNewBatch();
49                         break;
50                     case 5:
51                         DisplayAllEntities();
52                         break;
53                     case 6:
54                         Exit();
55                         break;
56                 }          
57             }
58         }
59 
60         private static void Exit()
61         {
62             Environment.Exit(0);
63         }

Insert a new entity

 1         private static void InsertNewEntity()
 2         {
 3             try
 4             {
 5                 var client = CloudStorageAccount.Parse(_connection).CreateCloudTableClient();
 6 
 7                 var table = client.GetTableReference(TableName);
 8                 table.CreateIfNotExists();
 9 
10                 table.Execute(TableOperation.Insert(
11                     new SomeEntity(PartitionName, Guid.NewGuid().ToString(),
12                         new Random().Next(0,9).ToString())));
13                 
14                 Console.Clear();
15                 Console.WriteLine(Success);
16                 Console.ReadKey();
17             }
18             catch (StorageException ex)
19             {
20                 Console.WriteLine(ex.Message);
21             }
22         }

Once I enter 1 as my choice, the function will be called to create a new entity with a random number between 0 and 9. When done it will display a message, either a success or an exception. Hitting any key will take you back to the main menu.

Below is the newly added entity to the Azure table.

Update a specific entity

To do that, you will have to do a retrieve operation first to get the entity and then afterwards update it and finally push it back. We will need both the Partition Key and Row Key to be able to retrieve the entity and update it.

 1         private static void UpdateSpecificEntity()
 2         {
 3             try
 4             {
 5                 var client = CloudStorageAccount.Parse(_connection).CreateCloudTableClient();
 6 
 7                 var table = client.GetTableReference(TableName);
 8                 table.CreateIfNotExists();
 9 
10                 Console.Clear();
11 
12                 Console.WriteLine("\nEnter partition key: ");
13                 var partitionKey = Console.ReadLine();
14 
15                 Console.WriteLine("\nEnter row key: ");
16                 var rowKey = Console.ReadLine();
17 
18                 Console.WriteLine("\nEnter some number: ");
19                 var someNumber = Console.ReadLine();
20 
21                 var retrieveOperation = TableOperation.Retrieve<SomeEntity>(partitionKey, rowKey);
22                 var retrievedResult = table.Execute(retrieveOperation);
23 
24                 var updateEntity = (SomeEntity)retrievedResult.Result;
25 
26                 if (updateEntity != null)
27                 {
28                     updateEntity.SomeRandomNumber = someNumber;
29 
30                     var updateOperation = TableOperation.InsertOrReplace(updateEntity);
31                     table.Execute(updateOperation);
32 
33                     Console.WriteLine(Success);
34                 }
35                 else
36                 {
37                     Console.WriteLine(Fail);
38                 }
39 
40                 Console.ReadKey();
41             }
42             catch (StorageException ex)
43             {
44                 Console.WriteLine(ex.Message);
45             }          
46         }

In the below screenshots you can see me updating one of the entities with Partition Key “Lesson02” and RowKey “aab27b1a-4a97-44b4-994c-daef89865d9a”.

Delete a specific entity

Delete shares the same logic as updates. You will have to retrieve the entity before deleting it.

 1         private static void DeleteSpecificEntity()
 2         {
 3             try
 4             {
 5                 var client = CloudStorageAccount.Parse(_connection).CreateCloudTableClient();
 6 
 7                 var table = client.GetTableReference(TableName);
 8                 table.CreateIfNotExists();
 9 
10                 Console.Clear();
11 
12                 Console.WriteLine("\nEnter partition key: ");
13                 var partitionKey = Console.ReadLine();
14 
15                 Console.WriteLine("\nEnter row key: ");
16                 var rowKey = Console.ReadLine();
17 
18                 var retrieveOperation = TableOperation.Retrieve<SomeEntity>(partitionKey, rowKey);
19                 var retrievedResult = table.Execute(retrieveOperation);
20 
21                 var deleteEntity = (SomeEntity)retrievedResult.Result;
22 
23                 if (deleteEntity != null)
24                 {
25                     var deleteOperation = TableOperation.Delete(deleteEntity);
26                     table.Execute(deleteOperation);
27                     
28                     Console.WriteLine(Success);
29                 }
30                 else
31                 {
32                     Console.WriteLine(Fail);
33                 }
34 
35                 Console.ReadKey();
36             }
37             catch (StorageException ex)
38             {
39                 Console.WriteLine(ex.Message);
40             }
41         }

In the below screenshots you can see me deleting one of the entities. Remember, you will always need the Partition Key and Row Key to retrieve entities.

Insert a new batch of entities

To insert a batch of entities, you will have to use a batch operation. In the below code we will insert 10 new entities every time the function is called.

 1         private static void InsertNewBatch()
 2         {
 3             try
 4             {
 5                 var client = CloudStorageAccount.Parse(_connection).CreateCloudTableClient();
 6 
 7                 var table = client.GetTableReference(TableName);
 8                 table.CreateIfNotExists();
 9 
10                 var batchOperation = new TableBatchOperation();
11                 for (var i = 0; i < 10; i++)
12                 {
13                     batchOperation.Insert(new SomeEntity(PartitionName, Guid.NewGuid().ToString(),i.ToString()));
14                 }
15 
16                 table.ExecuteBatch(batchOperation);
17 
18                 Console.Clear();
19                 Console.WriteLine(Success);
20                 Console.ReadKey();
21             }
22             catch (StorageException ex)
23             {
24                 Console.WriteLine(ex.Message);
25             }
26         }

Once done it will display a message, either a success or an exception. Hitting any key will take you back to the main menu.

Display all entities of single partition

Finally, we will use LINQ to query the table and get the entities of a specific partition. Up till now, you can do direct hits on string comparisons with the queries. You can not do stuff like Contains. I have been in project were we loaded tables into cache and did our LINQ queries there with Contains etc. Another option would be using Azure Search.

 1         private static void DisplayAllEntities()
 2         {
 3             try
 4             {
 5                 var client = CloudStorageAccount.Parse(_connection).CreateCloudTableClient();
 6 
 7                 var table = client.GetTableReference(TableName);
 8                 table.CreateIfNotExists();
 9 
10                 var query = new TableQuery<SomeEntity>().Where(
11                     TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, PartitionName));
12                 var list = table.ExecuteQuery(query).ToList();
13 
14                 Console.Clear();
15 
16                 foreach (var someEntity in list)
17                 {
18                     Console.WriteLine("{0}\t{1}\t{2}", someEntity.Timestamp, someEntity.RowKey, someEntity.SomeRandomNumber);
19                 }
20 
21                 Console.WriteLine(Success);
22                 Console.ReadKey();
23             }
24             catch (StorageException ex)
25             {
26                 Console.WriteLine(ex.Message);
27             }
28         }

In the screenshot below you can see the list of all entities sitting in the “Lesson02” partition.

aaaand we are done with the lesson. Let me know if you have any questions or comments

As I mentioned earlier, this a special series that focuses on a point, a task, a recipe. So don’t be surprised if we wont be building fancy samples, I am here to help you get on your feet with PaaS development on Azure.

What’s up for today?

I’ve been doing Azure PaaS development for a while now, and I can tell you that the best place to start learning the robes are Web Jobs. Let me quiz you quickly here: What would you do if you want to run background tasks, executable files, or even scripts on Azure? I bet you would say: let’s spin a new VM and put all that stuff there. Or at least that’s what we used to say before Web Jobs came to life. So in a nutshell, you can schedule and configure on demand executable applications and scripts to run on Azure without spinning a new VM  

Let’s get cracking

Below is a simple command line application that will print a time stamp. We will create a Web Job and configure it to run this application every one minute. Yeah I know a bit cheesy, but hey if you can come up with more meaningful examples, fire up the comments section below

 1 using System;
 2 
 3 namespace PaaS101.Lesson1
 4 {
 5     class Program
 6     {
 7         static void Main(string[] args)
 8         {
 9             Console.WriteLine(DateTime.Now);
10         }
11     }
12 }

Launch the Azure portal and head to Web Sites. Yep that’s right, Web Jobs sit inside Azure Websites and yes you can have multiple web jobs in the same Azure Website. Let’s create a new Website. I will use the same website through all the lessons. I called it paas101 and it will sit on https://paas101.azurewebsites.net.

Once created, click on paas101, select WEBJOBS tab, and create a new job.

Now you will have to compress your executable and their dependencies in one zip file. Since we decided to run it every minute then select “Run on a schedule” and choose your schedule region. Mine is “West Europe”.

Moving on to the next step, select “Recurring Job” for recurrence and set it for one minute. Looks like you have to specify and ending time. I just set it to 11:30PM today my time.

Once its done, you will notice that the status is set to “Enabled”. Let’s see how was the execution of our Web Job going. One of the columns is called “LOGS”. Navigate to the URL.

This is the logs URL for our Web Job: https://paas101.scm.azurewebsites.net/azurejobs/#/jobs/triggered/PrintTimeEveryOneMinute. Once you land on the logs page you will notice the previous runs below marked with a status:

Clicking on the web job will open the Web Job run details. As you can see from the screenshot below, the web job did print the time

I hope you enjoyed the quick 101. Let me know if you have any questions or comments. Until next lesson

What’s cooking for today?

We will use EWS managed API to get a list of calendar items for a specific group of people and put it in a table. To start, you will have to download and install EWS Managed API. At the time of writing this article, the latest version is 2.2 and can be found here: https://www.microsoft.com/en-us/download/details.aspx?id=42951. Once it’s installed, we are ready to get some code on. So go ahead and create your project. I will use Web Forms, nothing personal but I could bind quickly to a ASP.NET GridView. You will need to add the API assembly to the project from here: C:\Program Files\Microsoft\Exchange\Web Services\2.2. You will need to add a using statement for this namespace: Microsoft.Exchange.WebServices.Data.

Connect me to EWS

Since this is a Web Form, I will have my fun on Page_Load. I created a function called Populate Appointments to run the query for me. Notice that I defined the time period of the next 60 days. So logically I will get all appointments that will take place in the next 60 days for a specific group of people.

The PopulateAppointments function requires the following parameters:

• Instance of the Exchange Service which we defined at the beginning of the code block
• The group of people I want to query there calendars, To loosely-couple it, I created another function for you that returns the list of people called GetAttendees. It will return an IReadOnlyList of AttendeeInfo (Microsoft.Exchange.WebServices.Data.AttendeeInfo).
• A list of the types of meetings/empty slots to look for. The logic is kind of twisted here, yeah I get it. I could not find a way to send a query to get current meetings of a specific person, but if you do a lookup to schedule a meeting request you will get both empty and filled slots which is what we are looking for
• The time span, I used here 60 days. Note that by max you can do 62 days for a single request to EWS. I did not find this documented, I learned it when I got the following exception: (I used 90 days)

Finally, handle the redirection to validate if the callback is happening over a secure connection. I copied it from here: https://msdn.microsoft.com/en-us/library/office/dn567668(v=exchg.150).aspx

Let’s get some items

Before we can get the query to happen, let’s first look at the functions we used as parameter inputs for the PopulateAppointments function.

So far we have an Exchange Server to query; a the time period less than 62 days, and a list of people. Let’s start digging in the PopulateAppointments function.

aaand this is how it looks

Yepee We can see now only the meetings that matched our prefixes for a specific group of people and a specific time period. You can take this an extra level and place some fields to allow users to select the time period, or an export button to push this GridView into an Excel sheet, etc.

Let me know if you have any questions in the comments section below. Enjoy.!

You can always find the lesson source code attached at the end of the blog post.

As promised, by the end of this lesson you will start feeling like a Windows Phone developer. Till now, we learned how to build GUI using XAML, create event handlers, a little bit about the page cycle, saving data offline using the local storage, and finally navigating and sharing between pages. The only thing left to start producing real applications is data binding and communication with services.

What is Databinding?

Do you remember the News application from Lesson 3? Lets say we have bunch of news that we want to display to users. first thing we would ask our selves is how this news look like and how I want to display it to the user. For me, a news item should include a title, a small description, a picture maybe, and the actual text details of the news.

The process of attaching the news items to the UI is called Databinding, so when I have a data source and I want to display it contents on a page controls. Final part of Databinding is the fact that each attribute of the data will be bound to a control on the page. and that’s why its called Databinding.

However, we cant really display all the news with all its details on one page, this way the user will have to keep on scrolling to get to the next news item So what I would do is use 2 pages, one to display a list of the news, and when a news item is tapped we navigate to another page to display that news item details, sounds cool.

How to Databind?

Below is a list box defined. Notice that we can include a definition for how the list item would look like under the ListBox.ItemTemplate tag. DataTemplate will contain the blueprint aka the controls with the binding information. To bind a control, we look for the attribute we want to bind, for example we bind an image source to an Image control, and we bind a text to a TextBlock control.

I used a StackPanel to layout the item contents, simply an Image with a TextBlock next to it. It will look close to this:

Using the WCF service

I wont babble about WCF here, I will explain what this service is doing, download the code lazy and check it out, this is a Windows Phone post I have one class called WindowsPhoneLessonNews that contains a Title, Content, and Thumb properties. In addition, I have 2 Operation Contracts, one I will use to get all news items and the other will get a specific news item based on an index.

Let’s add a reference to our service to be able to consume it. Right click References and choose Add Service Reference.

I hosted the service in my local host at port 8080. Navigate to your service and select it. I gave the reference the name of Lesson4PhoneNewsService.

Since we have a reference to the service we can start with consuming it. First things first, let’s start with what happens on page load, I am assuming by now you know how to add an event handler for page load, if not go back to the previous lessons. Below you can see that I used an Async call to get all news items when the page loads. We are using Async so we make sure not to lock the GUI until we get a response from the service.

To spice the user experience I added a progress bar to the page and as long as we are expecting results from the service it will keep animating, otherwise it will be invisible for the user.

Since this is Async programming, we need to tell our application what to do when it gets a response back from the service. OK now the response is back, I will simply assign the ItemsSource of our ListBox to the result response I got from the service and hide the progress bar.

Makes sense right? I see the progress bar when the Aync call is active and it disappears when I have a response. Since I know that my service will return a generic list that I can bind to the ListBox, I directly set the source to the result.

So, what happens if I tap an item?

To handle the tap, lets create an event handler for when the list selected index is changed. I simply check that I have a valid index selected and then take the user to the details page passing the news item index in the query string. This way when the NewsDetails page loads, it can figure out which news item details to query render.

As for the details page, we will go through the same process. When loaded, consume the service to get the news item with the index passed in the query string.

and almost identical when comes to the delegated completion of the Async call

If you want to go back to the all news list just tap the back button on the phone.

Mirror Mirror who is the most beautiful of them all?

Below is the markup for the main page, Just included a TextBlock to say that we are getting the content from a web service bla bla (just felt like it hehe)

With that lets move to the NewsDetails page. Almost same XAML markup from the main page, I just changed the StackPanel orientation to Vertical, removed the image and included the news content. In addition, notice that I changed the font size to 40 for the news title.

Let’s test it out..!

When I first load the application I get the list of news, I did not really get creative about the news content just got phone models and their pictures and some lipsum content for the details.

When I tap a news item I get the item details page.

Summing things up after 4 lessons

So by now you have an informative idea about what it takes to write Windows Phone applications, we went through many topics of XAML and Markup Page construct, Layouts, Events Handling, Navigation, Databinding, Threading, and consuming Web Services in the past 4 lessons. Keep tuned, more to come

Let me know if you have any comments, requests, and feedback.

Lesson4.zip

You can always find the lesson source code attached at the end of the blog post.

As we explained earlier in Lesson 1, Windows Phone applications are made up of XAML pages. So the way you would think about it is the same way you think about a website. Every application will have some sort of a navigation logic. So for example if we have a news application, we would have a main page were the application lands when it launches displaying news categories. You then would need to select a category and then it will display the list of news inside that category and if you tap on a news item, it will display the news details. I guess by now you get the drift  

We will talk in details later during the data binding lesson about templates and capturing selected list items, but for now we will need to navigate between the pages and pass parameters. So lets focus on that. You have my word, by the end of the next lesson where we talk about data binding you will be able to deliver enterprise level applications. Be cool

So, How does it look like?

Lets have 2 pages, MainPage labeled as Page1 will accept a text string from you and pass it to Page 2 to be displayed.

As you guessed, again it’s a StackPanel , TextBlock for our user message, a TextBox to capture the user string, and a button to navigate to Page 2 passing the string.

Now for Page 2:

Good guess again, one StackPanel with 2 TextBlocks, one to display our message to the user and another to display the string entered in page 1. I added a button so you tap it will take you back Page 1.

Passing Query String Parameter(s)

On our first page, double click the PassParameter button to create an event handler. To navigate to a new page we use the NavigationService.Navigate function passing to it a URI. Check out below where I simply navigate to page 2:

and then if you want to add the Query String parameters we can do it add hoc like this:

specifying a parameter called UserString and pushing into it the user input from the TextBox. I am a web developer and when I see this you can see me smile It’s the same process exactly but instead you call Response.Redirect function instead.

For me I prefer to use the string.Format function instead  because I feel easy around it in adding a good number of parameters and just using curly brackets with index numbers without worrying about string contacts.

So eventually my button code is simple, I just call for Page2.xaml passing the contents of the TextBox in a parameter called UserString.

Retrieving Query String Parameter(s)

Logic should be simple for Page2. on page load we need to capture the Query String parameter and display its content inside the TextBox. To access the parameters we access the NavigationContext.

and finally we set the last event handler to take us back on the Go Back button. For that we used the NavigationService.GoBack function.

Let’s test it out..!

Run the emulator using the F5 key and please be patient until Visual Studio manages to compile, build, and deploy our application. Input some text into the text box and then hit on Pass Parameter.

and here you go with Page 2

and when I tapped Go  Back, it actually took me back again to the first page. Notice how it preserved the string you entered before navigating away from it. But this is a discussion for another lesson.

So to warp it up we use NavigationService.Navigate to navigate between pages. The navigate URI can accept parameters which can be shared with target pages. Finally, we use the NavigationContext to access the passed Query String parameters.

I hoped you enjoyed this lesson

Lesson3.zip

Before we move on, you need to have a basic understanding of event handling. I went through this in Lesson 1. Please finish it first before moving on.

Two questions would pop in your head, one would be about utilizing storage for your app on an SD card, and the answer yes and the next question would be about the size limit, so as I know (and I know little ) you will have virtually no constraints on the application storage capacity. So as long as you have storage available in your device then your app can utilize it.

The idea of our application is very simple, I will use the local storage to read/write a string message and a counter to a text file. I will be increasing the counter every time we launch the application (aka load the page) and will display the last message stored in the text file.

You can always find the lesson source code attached at the end of the blog post.

So, How does it look like?

As you figured we used 2 TextBlocks to display the message and the counter and one TextBox to capture the new message if any. So what about the XAML behind this, well as always StackPanel is my hero:

In this scenario we named the TextBlocks because we will be pushing content to them from our code behind. So lets start with what happens when the page loads.

So what happens when the page Loads?

Before we start with the page load logic, please make sure to add the following using statements on the top of the page to be able to use the isolated storage and carry on file operations.

On page load I need to check if the file I use to store the string and counter exists or not. If it does exist I read the counter and the message and push them to global variables. If the file does not exist, I write 0 and “No messages..!” in a new file. The file I will be using will be called LS.txt (short for Local Storage), I know very impressive naming skills .

Finally, I push the values to the TextBlocks by replacing the “##” symbols in my string with the variable values using the string.Replace function.

and when it Unloads?

when the page unloads or navigated away from using the Back or Start buttons, we replace the current LS.txt file with the new content. First we increment the counter and then add the message.

The final part of our application is saving the new message and exiting the application so that we call the OnNavigatedFrom handler.

Save New Message

We push the contents of the TextBox back to our variable and push a message box to the user.

Let’s Test it out..!

Run the emulator using the F5 key and please be patient until Visual Studio manages to compile, build, and deploy our application.

The application loads with the counter set to 0 and I input a message.

Now I will hit save and the application will display the message box. We will exit when the message is dismissed which will call the unloaded and increment the counter and save my new message.

Once you hit back after dismissing the application, go to the menu again on the phone and click on Lesson 2.

and taraaaaaaaaaaaaaaaaaa..!! we have an updated counter and our last message:

I hope enjoyed your lesson today and have an idea on how to read and write files in Windows Phone.

Let me know if you get stuck somewhere.

Lesson2.zip

• Application Layout and Events Handing
• Access to Application Isolated Local Storage
• Navigation between Pages and passing Parameters
• Communicating with Services and Data Binding
• Threading and Asynchronous Calls
• Access to Phone Resources like Address Book and GPS
• Panorama and Pivot Applications
• Animation and Transitions using Blend for Visual Studio 2012

and the list will keep on growing  

To get you up to speed, you need to download the Windows Phone SDK 8.0 from: https://dev.windowsphone.com/en-us/downloadsdk.

As I mentioned earlier, this a special series that focuses on a point, a task, a recipe. So don’t be surprised if we wont be building fancy samples, I am here to help you get on your feet with Windows Phone Development as soon as possible.

You can always find the lesson source code attached at the end of the blog post.

Quick facts before we start

• Windows Phone applications are constructed of XAML pages
• XAML pages are used to set the page layout and there is a CS or VB file tied to it for our code like event handlers
• XAML is somehow like HTML, we describe how the page would look using tags

Creating the application

Step	Details
1	So lets start with launching Visual Studio and creating a new Windows Phone App Project. I will be using Visual C#. I called it Lesson1 You will be prompted to choose the platform you are targeting, 7.1 that is Mango and 8. Up to my knowledge, mostly whatever you build on 7.1 can work on Windows Phone 8 but not the other way around. I choose Windows Phone OS 8.0.
2	Once Visual Studio loads the project files, you will notice that you have live preview on the left and the XAML editor on the right. I will not rely that much on the designer during this series because of the nature of the topics being discussed, almost all topics are code running behind so for now kiss the designer goodbye.

How do you describe your application pages using XAML?

There are lots of controls for you to do so like a Grid, a Canvas, or my favorite a StackPanel. In this lesson we will use the StackPanel to describe our page layout.

How does a StackPanel actually work?

I love StackPanels because you can stack controls on either horizontally or vertically with now swat, you can even have a StackPanel stacking another StackPanel, how cool is that?

Check the code below: I laid 2 StackPanels inside the ContentPanel, one with Horizontal orientation and the second with Vertical orientation each containg 4 buttons.

and then check the designer screenshot rendering both StackPanels below:

XAML is simple to use, we use the tags to layout controls and predefined properties to describe their behavior or format. You will get used to it quickly.

So, what’s cooking today?

A lame sample indeed , So I was thinking of asking the user to enter 2 numbers and then we multiply them and return the result either in a message box or simple push it back in a label somewhere on the page for the user. It will look like this one below:

Layout is simple, we have 2 StackPanels like the first example above with the 4 buttons, but this time instead of stacking buttons in the first StackPanel, I stacked text and input boxes. From now on, we refer to text on application page as TextBlock and input boxes as TextBox.

Notice that I added an InputScope to the TextBox telling the application that we want the numbers keyboard to show up instead of the normal full keyboard when capturing user input:

What about my code?

We have a the layout ready and all we need to do is tell out application how to behave when something happens on the GUI aka an Event.

Step	Details
1	Wiring up even handlers with the GUI is simple thanks to Visual Studio. Just select your desired control in our case the Messagebox button and double click on it. Another way of doing this is that after selecting go to the Properties pane on the right bottom of your screen (I had to drag it next to the control for the screenshot) click on the Lighting button which will display all the element events and then double click on the empty textbox next to Click.
2	Visual Studio will load the CS file associated with our XAML page now and create an empty event handler for you. The behavior is simple, we are pushing a MessageBox to user with the result. The MessageBox.Show function accepts a string which means I have to do the calculation and then cast it as a string using the ToString function. To give the more context we pull the values of the 2 numbers and push a string to the user that say 2 X 2 = 4. I hope it looks more simpler now. Note that I used the double.Parse method to cast the TextBox string value to a number of type double.
3	Repeat Step 1 but this time on the other button and update the even handler code. The behavior code is simpler than the message box because we are not concatenating strings, we just push the result to a TextBlock.

Let’s test it out..!

The SDK comes equipped with an Emulator, we will cover this in later lessons, but for now just hit ctrl+F5 to Build and Deploy our application to the emulator and run it. Please be patient and wait until it loads our application. Once loaded, enter some values for X and Y. Notice how the numbers keyboard is shown instead of the full keyboard.

Now try once to tap the Messagebox button and another time the TextBlock button.

I hope you enjoyed the lesson, to sum it up:

• Windows Phone applications are made up of XAML pages
• We use XAML markup to describe our page layout and code behind CS or VB files to write our event handlers
• Controls are represented like HTML markup in tags, each control has its own properties to define its behavior and format like the setting the InputScope for a TextBox
• To wire an event handler to a control we simply double click the control on the designer view or select it and navigate the event handlers property sheet using the properties window.
• Anything pushed/input to/from the screen is considered a string
• We use the double.Parse to cast from a string and ToString to cast to a string
• To build, deploy, and run our code we use ctrl+F5 keys, this will launch the emulator, deploy, and run our application

Let me know if you have any questions

Lesson1.zip

Step	Action
1	Launch the BizTalk Server Administration console from the Start menu.
2	Right click Custom Views under Event Viewer and select Create Custom View.
3	Use the Filter tab to select the BizTalk Server and XLANG/S from Event Sources dropdown when filtering By Source. According to this MSDN article we should consider the XLANG Scheduler as an events source too. Its up to you to add as much related sources to your deployment. In case Event Sources dropdown fails to render items, which happened to me couple of times when using Event Viewer with BizTalk Administration in the same console . Either launch the Event Viewer from Administrative Tools or simply click on the XML tab and place a check on Edit query manually. You can use XPath to write the filter. If you are interested in writing XPath quries to filter events, this article will be an excellent starting point: Advanced XML filtering in the Windows Event Viewer. Please note that you can either use XPath in the XML tab to write your filter or the GUI in the Filter tab. You can't edit your filter using both tabs.
4	Fill the name of the new custom view. I chose BizTalk Server.

and you’re finished