MyVBProf.com

Windows Store Applications

Burrows — Sun, 17 Feb 2013 21:08:18 GMT

This tutorial brings together most of the main concepts needed to create a Windows Store application. Using the “Golf Tutorial” example that I have used for other technologies, this sample application is “almost” ready for the Store.

The application stores and manages data on the local machine using SQLite. It provides the user with the ability to store information about golf courses and rounds of golfed played on the courses. It also calculates the golfer’s handicap index as well as the handicap for a specific course.

WinRT concepts used in the application include state management, navigation with multiple pages, “app” bars, and view management such as the “Snapped” view.

To introduce all the functionality and technology, the tutorial includes 18 videos. Hopefully when you complete the tutorial, you will have the skills needed to build your own Windows Store application.

Enjoy … bill

Tutorial – Windows 8 for a Windows 7 User

Burrows — Sun, 03 Feb 2013 19:33:56 GMT

Unlike most of my tutorials, this tutorial is not intended for the developer world. I have been contacted by a number of “normal” people who have been using Windows 7 for some time but are now a bit puzzled by their initial experience with Windows 8. Given the experience of these folks, I decided to put together a short tutorial designed to give some guidance to Windows 7 users who are new to Windows 8. This tutorial focuses on using Windows 8 in a “non-touch” environment such most desktops and many laptops.

In this tutorial, we first focus on the Start Page that is the first page you see after logging into Windows 8. I would guess that this is the most confusing thing that former Windows 7 folks encounter when they move to Windows 8. We talk about organizing the tiles on the Start Page, the “charms”, and changing settings.

The next video focuses on the more familiar desktop. There are some changes here for a Windows 7 user but most Windows 7 folks know what is going on here and wish they had landed here after logging in.

Finally, we look at Windows 8 applications, explain how they differ from traditional desktop applications and explain some of the reasons why Microsoft adopted the Windows 8 application design concepts.

Enjoy … bill

WinRT and SQLite Tutorial

Burrows — Mon, 10 Dec 2012 20:23:34 GMT

Some WinRT applications can benefit from having access to the storage system on the client. While there are useful APIs that access the local file system (under some constraints), sometimes working with a data management system is desirable.

SQLite provides such data management features with a small footprint. With the proper helper tools, access to the data can be handled through Linq and some very useful extensions to SQLite can be used to manage the tables.

This tutorial has two parts. The first part shows you how to set up a Windows Store application with the necessary references to SQLite and some helper methods. While there are some nice blogs available that demonstrate this, the blogs use C# and this tutorial focuses on Visual Basic (there are some differences).

The second part demonstrates the use of a SQLite database. It creates a table, populates the table with some sample data, and then demonstrates a Linq query to access the records in the table.

WinRT Split App Template Tutorial

Burrows — Fri, 02 Nov 2012 22:27:32 GMT

There are two templates available for Windows Store applications that include all the features of a complete application. These are the Split Application and the Grid Application.

Each application includes a “sample data model” that is thoroughly linked to the pages as well as the CSS created by the template. The idea is that developers will substitute their own data model for the sample one. However, this is not necessarily an easy task.

In this tutorial, we look at the Split App template and its included sample data model. We use the OData AdventureWorks data service and show how it can be linked to the sample data model.

WinRT State Management Tutorial – Part 2

Burrows — Sun, 21 Oct 2012 18:58:17 GMT

This is part 2 of the WinRT tutorial set that demonstrates how to manage the various states that a WinRT application experiences.

In this tutorial, a multi-page application is created using the AdventureWorks OData web service as the source of the data. The application displays the AdventureWorks Product Catalog. It filters the data based on the product categories and gives the user the opportunity to drill down on product details.

The application demonstrates how to insure that a terminated application returns to the correct page when it is restarted. It also shows how to restore list indices when the application restarts.

As a side benefit, the data model used in this application shows how to asynchronously access an OData web service and expose the members associated with that service.

WinRT State Management Tutorial

Burrows — Wed, 19 Sep 2012 22:36:35 GMT

WinRT applications transition between a number of different states. Closed applications transition to running applications. Running applications can be suspended or closed. Suspended applications can be resumed or terminated.

Understanding these states and maintaining correct Application and Session State is critical to the UX. In this tutorial, we explain the various states and the transitions between them. We build a simple winRT application that manages Application State, such as preferences, using the new “roaming” feature of winRT and Windows 8.

The sample application also shows how to save and restore Session State that includes the data a user has entered when an application is suspended, terminated, and then restarted within a session.

This tutorial demonstrates all the concepts and code associated with state management. In part 2 of this series, state management of an application with a more complex UI will be demonstrated.

WinRT Async Tutorial

Burrows — Sat, 30 Jun 2012 19:53:00 GMT

WinRT applications, available on both Windows 8 and Windows RT operating systems, make extensive use of asynchronous programming concepts. In fact, with WinRT, Microsoft has followed a simple rule: if an API is expected to take more than 50 milliseconds to run, the API is asynchronous. The rationale behind this decision was to make user experience fluid and not hang or block the UI while an operation is being completed.

In this tutorial, we create two simple applications that demonstrate the use of asynchronous programming using direct API calls as well as writing custom methods that are asynchronous. We discuss the ‘Await” keyword and how it is used. We also demonstrate the concepts of an asynchronous ‘task’ and how we use tasks to implement asynchronous activities.

Windows 8, Metro, and Windows RT

Burrows — Sat, 05 May 2012 17:34:59 GMT

As Microsoft moves toward the release of their new operation system(s), there continues to be some real confusion about terminology and features. I recently was asked by the author of a college textbook to help explain what is happening in the Microsoft space. Below is my response to him.

A good description of what is happening can be found in Brandon LeBlanc’s blog. Windows 8 is the official name for the product that supports x86/64 architectures. Remember that these architectures can be found in both desktop machines and tablets so it is important not to associate Windows 8 with just desktops.

In fact, Windows 8 will include two “modes”. One mode is the classic “desktop” mode and should be viewed as an upgrade from Windows 7. There are no restrictions on storing data or consuming resources because it is assumed that the machine will be connected to external power. However, the other mode, called the “Metro” mode, will restrict applications in terms of the resources they can use and will change how the user will interact with the application. Some of the restrictions include not supporting databases on the client and requiring all communications to be done asynchronously. Interactions will be touch sensitive and respond to a variety of “finger gestures” for user interaction. While metro applications will run fine on the desktop using the mouse and keyboard, they are really designed to focus on the tablet market. Finally, even though a Metro application may be running on a desktop machine plugged into the wall, the restrictions associated with restricted resource consumption will still be enforced.

Windows RT is the product that is being released for ARM processors. These devices are less expensive and typically target the handheld (tablet) market where weight and battery life are really critical. I would describe this product as “Windows 8 Metro” for ARM architectures. Unless you know what processor is in your tablet, it would be hard for the user to know if they were using Windows 8 Metro or Win RT (the functionality would be almost identical). Windows RT will likely NOT be sold to end users but instead installed by the OEM.

I see the Windows RT devices targeting the mass market and specifically provide Microsoft with an iPad competitor. Business users will more likely use Windows 8 Metro mode for their tablets because of the greater flexibility and application support.

Just to make things more complicated, Microsoft is also releasing WinRT (not to be confused with Windows RT). WinRT is an API that sits side-by-side with the .NET framework and the Win32 API. Applications can choose to use either the old Win32 API or the new WinRT but not both. Applications developed for Windows RT and Windows 8 (Metro mode) use the WinRT API. It is this API than enforces the resource consumption constraints pointed out earlier. Rocky Lhotka has published a very nice discussion of WinRT that I would highly recommend.

I hope this helps.

bill

New MVVM Tutorial

Burrows — Sat, 28 Apr 2012 20:13:00 GMT

With the increased importance of XAML in Windows 8, I have decided to update my tutorial on the Model View View-Model pattern. As I said in my original MVVM tutorial, I finally understand the pattern well enough to make some intelligent comments about its use.

The tutorial begins by contrasting the traditional “code behind” approach with the MVVM approach and provides motivation for using the MVVM pattern. The tutorial uses a Silverlight client as the demonstration application. We start by building a simple view model that downloads data from a RIA Data Service and exposes the collection of data to the UI. We then add CRUD (minus the update) functionality to the application and show how our view model handles these requirements.

The tutorial uses Visual Studio 11 beta and Visual Basic. If any changes are needed after VS 11 is released, I will update the tutorial appropriately.

When the tutorial is complete, a simple functioning application is created using the MVVM pattern and zero lines of code behind.

New Website Design

Burrows — Sat, 28 Apr 2012 19:50:52 GMT

I have just launched a new web design for myVBProf.com. The new site is HTML based and uses some HTML 5 features. I have tested it with current releases of the major browsers and have not encountered any issues.

New videos will be published on the new site and will focus on Visual Studio 11 (or whatever it will be called) and Windows 8. The new site has a link to the old site where all current videos still live.

When a new tutorial is published that updates an existing tutorial, the link to the one being replaced will be deleted.

bill

Procrastination

Burrows — Wed, 25 Jan 2012 18:51:57 GMT

In a previous post, I outlined what I plan to do regarding Silverlight 5. As I started working on the material, it became clear to me that I wanted to use the new dbContext class that is now available in Entity Framework 4.1 (and later releases.) However, to use this with the current version of WCF Data Services is not as clean as I like. So I am going to delay the series until things get synched up.

We are at one of those points within the Microsoft “developer stack” where things are in flux and will likely stay that way until VS 2012 (or whatever it will be called) is released. For someone trying to generate tutorial material, creating content that has a shelf life of several months is not desirable.

I will be attending the MVP Summit in late February. While I will not be able to share any NDA information, I will get to meet with many teams at Microsoft and get a better idea on when I can feel comfortable getting content out that will have some longer-term value.

bill

Silverlight 5

Burrows — Wed, 11 Jan 2012 00:17:27 GMT

Microsoft released Silverlight 5 in December 2011. As you may have noticed, I have done a number of Silverlight tutorials as the product evolved from version 2 to version 4.

There has been a lot written about the future of Silverlight. Will there be a version 6? What will happen to the browser plug-in? I would like to refer you to a great article titled Silverlight 5 released; will there be a Silverlight 6? by Peter Bright for what I think is a great discussion of the issues.

For me, I plan to redo the current Silverlight tutorials using version 5 because I believe many business applications may continue using Silverlight. In addition, understanding Silverlight is a great way to get a handle on WP7 development and this provides another rationale for updating the tutorials.

Right now I plan to publish the following Silverlight 5 tutorials:

Basic Silverlight Business Application Concepts
Working with RIA Data Services
Deploying a Silverlight Application
Golf Reference Application (Traditional Code Behind)
Golf Reference Application (MVVM)

After getting these tutorials published, I will likely just wait and see what happens with Silverlight in the future.

bill

Win 8/Metro–A First Look

Burrows — Mon, 03 Oct 2011 19:17:29 GMT

Microsoft is making a big strategic shift in their operating systems and applications. They have decided that they must target a broader set of platforms with a single integrated approach. To this end, they announced Windows 8 and Metro applications at the recent BUILD conference.

In this tutorial, we take our first look Win 8 and build a Metro application. We use Visual Basic as the code-behind to write an application that presents the contents of a blog site.

You’ll see how Visual Basic and XAML can be used to create a Metro application. You’ll also get a look at Win 8 and see how applications are presented using the “Metro” approach.

There are numerous new ideas, concepts, and even new vocabulary associated with the new Windows OS/Metro ecosystem. Links are provided with the tutorial to help explain some of these issues.

bill

WP 7.1 (Mango)–DataServiceState Tombstoning

Burrows — Fri, 24 Jun 2011 17:32:00 GMT

Windows Phone 7.1 (Mango) OData uses a different approach for tombstoning the Data Service State of an application. In this tutorial, we take a WP 7.0 application and convert it to WP 7.1.

In Mango OData, methods have been added to the DataServiceState class that improves performance and functionality when storing client state. You can now serialize nested binding collections as well as any media resource streams that have not yet been sent to the data service.

The conversion of the WP 7.0 application to WP 7.1 involves targeting the application to WP 7.1, revising the client data classes to support serialization, and modifying the App.xaml’s Application_Deactivated and Application_Activated events to use the new DataServiceState’s Serialize and Deserialize methods.

bill

WP 7.1 (Mango) First Look Tutorial

Burrows — Fri, 10 Jun 2011 17:52:00 GMT

Windows Phone OS 7.1 – code named Mango – has been released as a beta from Microsoft. This release includes a significant number of enhancements and new features compared to the initial 7.0 release.

This tutorial provides an introduction to the Mango release. The sample application we create uses new OData features to access a database using a WCF web service. The OData enhancements that are demonstrated include the automatic generation of the OData client classes and the use of LINQ to support queries.

In addition, the new Rapid Application Switching feature, aka the “dormant state”, is demonstrated and contrasted against tombstoning.

Enjoy … bill b

WP7 – Handling OData Async Callbacks

Burrows — Fri, 29 Apr 2011 21:19:49 GMT

In the original WP7 Golf Application tutorials (WP7 – Parts 1, 2, and 3), the handling of asynchronous data loading using the DataServicesCollection was not handled very well. In this tutorial, that issue is highlighted and a better solution is provided.

In this tutorial, we take advantage of the ‘LoadCompleted’ event to manage the user interface and enable capabilities when the asynchronous calls to the data service are completed.

If you are working with a remote database and using OData to manage the service calls then you want to check out this tutorial.

bill

Deploying a Silverlight Application

Burrows — Tue, 26 Apr 2011 19:21:27 GMT

It is always a challenge to get an application you have working with on your development machine deployed to a server so others can access it. The frustration is compounded because it seems that a very popular alternative for many of us, that is, the shared hosting provider, is rarely covered in the MSDN documentation.

In this video, I show you how to deploy a Silverlight Business application to an ISP that provides hosted services. The sample application includes two databases; one to support the application and a second to support registration and authentication.

I am using DiscountASP.NET in the tutorial and want to thank them for providing a promotional account for my use. I should point out that other ISPs provide shared hosting for Silverlight but would likely have different control panels. There may be some vendor-specific differences in the control panels that you will have to deal with. However, I suspect that once you understand the overall concepts, any differences will be fairly easy to overcome.

bill

LightSwitch Tutorial on Data Design

Burrows — Sun, 03 Apr 2011 18:14:11 GMT

LightSwitch uses an entity model to describe the data design. Folks with relational database experience need to understand how an entity model differs from a relational model. Folks with little or no database experience tend to design databases that look more like an Excel spreadsheet than a decent data design. This tutorial is intended to address both of these issues.

For Relational Database Folks

When you create your data model in LightSwitch, you are working with an entity model. LightSwitch and the Entity Framework work in the background to store the data in a relational database.

Those familiar with relational databases and relational models need to understand how they differ from entity models. This set of videos is designed to highlight the differences so that the relational database person can feel comfortable working with entity models.

For Non-Database Folks

You are a business domain expert and do not have training in designing a database. LightSwitch can help you with this task. However, there are a few basic concepts that you need to understand in order to minimize redundancy and keep data consistent.

This set of videos is designed to help you understand where you might go wrong and provides direction on avoiding the main design problems that can creep into a design. It is really important that you understand the issues covered in this tutorial and avoid them through careful design.

Enjoy … bill

New LightSwitch Tutorial

Burrows — Sat, 26 Mar 2011 21:26:02 GMT

I have posted the first of several tutorials on Microsoft LightSwitch. LightSwitch is a new Visual Studio development product. It supports the development of data-enhanced applications with a minimal amount of code. It is targeted at the professional developer, but importantly, it is also targeted at the business domain expert (someone who is not a professional developer but who wants to write an application to support her activities.)

In this introductory tutorial, we look at basic LightSwitch concepts and build a simple application. We create a database that supports storing information on students and the courses they have completed. We also create screens that can be used for data entry and reporting. All the functionality of the application is done by writing only 3 VB statements (two to enhance readability and a third to implement a business rule.)

This tutorial uses all default behavior. Look for additional tutorials were we drill down to explore the various features that can be used to customize an application.

Enjoy … bill

New MVC 3 Tutorial Available

Burrows — Thu, 17 Feb 2011 01:05:24 GMT

I have just posted a tutorial video on using Microsoft’s MVC 3.

Microsoft’s MVC 3 has been released. One of the major new features is the inclusion of a new view engine named Razor. Razor has a syntax that is described as compact and flexible. Unlike ASPX syntax, Razor does not use multiple keystrokes for its delimiters and also does not need closing delimiters. The parser is smart enough to infer the end of code and the start of HTML. This enables a really compact and expressive syntax which is clean, fast and fun to type. Razor also includes VB (as well as C#) code syntax so no new coding skills are needed. Additionally, it is designed to facilitate a really great Intellisense experience.

This tutorial builds the Golf Handicap Application using MVC 3 and Razor. It demonstrates creating controllers and views to facilitate creating, editing, deleting and displaying records. It works with the Entity Framework to provide the model to support the database. The model also demonstrates how one can use a Presentation Model to aggregate data from several entities.

bill