Category Archives: Uncategorized

Windows Apps JumpStart Publish Hack

Don’t forget, if you can get to London on Saturday September 20th, come to our Publish Hack at Microsoft’s Cardinal Place offices near Victoria Station and get your app published to store! Our goal for this day is to make it a fun, informal day where you can overcome those last blockers and issues that are preventing you getting over those last yards to publication. There will be fun, and pizza, and beer….oh, yes – and prizes!

We will have experts from Microsoft and from the developer community there to help you, including elite Windows App engineers from our App Consult program.

Did I mention prizes? Yes, as if the fun of taking part wasn’t enough, we’re going to give you additional incentive to take part by offering prizes, including:

– Nokia Lumia 1020 phones

– Nokia Lumia 1520 phablets

– Nokia Contactless Charging units

– Arc Mice

– Arc Keyboards

– A Goodie bag for every single developer that publishes an app on the day!

The prizes will be awarded for quality, progress made and for good old-fashioned sweat and tears.

Details and registration page:

Windows Apps JumpStart Publish Hack
Saturday 20 Sep – 9AM – 9PM
http://aka.ms/winappspublishhack 

Hope you can come along!

Windows Apps JumpStart LIVE Events Series

We’re starting a new series of events for UK developers that will help you on the journey from initial interest in developing apps for Windows 8 and Windows Phone right the way through to publishing an app to the Windows Store. You can join into the series at whichever point makes sense to you, so whether you’ve never opened Visual Studio before or written a line of C#, or you’re a developer who has already written software using out tools and languages but are new to apps, we can help you get to that point where you’re publishing your first app into our store. And we’re going to repeat the series of events every quarter, so you can jump on and off the series and attend events at whatever pace makes sense to you.

We start with two one-hour webinars run back-to-back:

Webinar 1: Windows Apps JumpStart LIVE Series – Kick Starter Webinar for the non C#/XAML developer: This one hour webinar is aimed at developers who are completely new to Visual Studio, XAML, C# and .NET. This will give you what they need to get started with downloading Visual Studio, a little bit of knowledge of C# and the structure of a XAML-based app.

Webinar 2: Windows Apps JumpStart LIVE Series – JumpStart Webinar: Building Apps with C# and XAML: This one hour webinar follows on straight away after the previous one. It is aimed at developers who are new to Windows Store app development, but who have some experience of developing software using .NET, or for those who have attended the previous webinar.

Following on from the webinars, we have a one-day dev camp:

Dev camp: Windows Apps JumpStart LIVE Series: Windows Apps Dev Workshop
This one day event will be help at Microsoft’s offices near Victoria Station, London, running 9:30 – 18:00. At this workshop, you will learn how to program Windows and Windows Phone apps, including universal apps that run on both. There will be Hands-on Labs available, and you can get tips and advice from Microsoft experts and from peers in the developer community.

And following on from that, we have a one-day Publish hackathon:

Publish event: Windows Apps JumpStart LIVE Series: Publish Hackathon
This informal one-day event will also be held at Microsoft’s building in London, running 9:00 – 21:00 on a Saturday. This is a fun 12 hour event encouraging developers to bring their existing projects (apps/cloud projects) to polish and publish through to the last mile with help from Microsoft and community experts.

First events are coming up fast!:

Come along and join us – and if not this quarter, remember we are repeating these events throughout the year so you can join us when you can!

How to massively improve SQLite Performance (using SqlWinRT)

Use ConfigureAwait(false) on calls to SqlWinRT async methods to improve INSERT performance up to 145 times, and SELECT performance up to 80 times 

Sample project: SQLitePerformance.zip

I have been seeing a few comments by people complaining of poor performance when executing SELECT statements against a SQLite database using the SQLWinRT wrapper, or when adding new records using multiple consecutive INSERT statements.

With many relational databases, poor performance on INSERT can often be rectified just by wrapping all your operations within a single transaction. If you don’t explicitly declare a transaction when programming against SQLite, the database engine creates an implicit transaction for each statement execution and that has an overhead associated with it, so by wrapping all your INSERTs inside a single transaction, you would expect a performance boost.

With SELECT operations, poor performance is often just down to not having the correct keys defined. If you have a statement such as SELECT * FROM CUSTOMER WHERE NAME = ‘CONTOSO’ and you execute it on a database where you have not defined a key on the NAME column, the only way the database engine can find the required record is to start at the first record and read sequentially down the table until it reaches the end in order to select the rows to return (called a ‘Table Scan’). If you simply want to select all the records in a table (SELECT * FROM CUSTOMER), then you can’t avoid the Table Scan – in fact that’s what you want – so you would expect that there wasn’t very much you could do to improve performance in that case.

Well – that’s the theory. I set about building a simple demo to demonstrate these points, but it didn’t turn out quite how I expected! It turns out that, important though the points already mentioned are, the most important factor BY FAR is how you call the async methods of the SQLWinRT API! Read on…

The Test Program

For my test program, I was inspired by this post on Stack Overflow: How do I improve the performance of SQLite. That post is quite old and is talking about C++ dev, so not directly relevant to Windows Phone or Windows Store app development using managed code, but I liked the test case, which was to take a large dataset from the City of Toronto’s publically available transportation data. Unfortunately, the exact same dataset used in the original post isn’t available anymore, so I couldn’t do a direct comparison, but they did have the Transportation Trips dataset, containing 128982 records that we can first insert into a SQLite database, and then select them out again.

SQLite Bulk Insert

The dataset is in the form of a CSV text file, representing 128982 rows, each containing 8 columns. The code to read the file and extract the values  looks like this:

SQLiteWinRT.Database db;

private async void Button_Start_Click(object sender, RoutedEventArgs e)
{
    int Route_ID;
    int Service_ID;
    int Trip_ID;
    string Trip_Headsign;
    int Direction_ID;
    int Block_ID;
    int Shape_ID;
    bool Wheelchair_Accessible;

    Button_Start.IsEnabled = false;

    /*********************************************/
    /* Open the Database and create the Schema */
    await LoadDatabase();

    Stopwatch sw = Stopwatch.StartNew();
    int n = 0;

    // Prepare statement
    using (var statement = await db.PrepareStatementAsync(
        @"INSERT INTO TTC (id, Route_ID, Service_ID, Trip_ID, 
                           Trip_Headsign, Direction_ID, Block_ID, 
                           Shape_ID, Wheelchair_Accessible) 
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"))
    {
        // Start transaction
        await db.ExecuteStatementAsync("BEGIN TRANSACTION");

        /*********************************************/
        /* Open input file and import into Database*/
        var inputfile = await Windows.ApplicationModel.Package.Current.
            InstalledLocation.GetFileAsync("trips.txt");
        using (var inputStream = await inputfile.OpenSequentialReadAsync())
        {
            using (StreamReader rdr = 
                new StreamReader(inputStream.AsStreamForRead()))
            {
                while (true)
                {
                    string inputline = await rdr.ReadLineAsync();
                    if (inputline == null)
                        break;

                    // Discard line 0 - header line
                    if (n > 0)
                    {
                        string[] fields = inputline.Split(new char[] { ',' });

                        Route_ID = Int32.Parse(fields[0]); ;
                        Service_ID = Int32.Parse(fields[1]);
                        Trip_ID = Int32.Parse(fields[2]);
                        Trip_Headsign = fields[3];
                        Direction_ID = Int32.Parse(fields[4]);
                        Block_ID = Int32.Parse(fields[5]);
                        Shape_ID = Int32.Parse(fields[6]);
                        Wheelchair_Accessible = fields[7] == "1" ? true : false;

                        /* Bind parameter values and Insert */
                        statement.Reset();
                        statement.BindIntParameterAt(1, n);
                        statement.BindIntParameterAt(2, Route_ID);
                        statement.BindIntParameterAt(3, Service_ID);
                        statement.BindIntParameterAt(4, Trip_ID);
                        statement.BindTextParameterAt(5, Trip_Headsign);
                        statement.BindIntParameterAt(6, Direction_ID);
                        statement.BindIntParameterAt(7, Block_ID);
                        statement.BindIntParameterAt(8, Shape_ID);
                        statement.BindIntParameterAt(9, Wheelchair_Accessible ? 1 : 0);

                        await statement.StepAsync();
                    }

                    n++;

                    if (n % 100 == 0)
                    {
                        progressBar.Value = n;
                    }
                }
            }
        }

        // Commit transaction
        await db.ExecuteStatementAsync("COMMIT TRANSACTION");
    }

    db.Dispose();
    db = null;

    var report = String.Format(
        "Inserted {0:d} records in {1:0.00} seconds", 
        n - 1, 
        (double)sw.ElapsedMilliseconds / 1000);
    MessageBox.Show(report);

    Button_Start.IsEnabled = true;
}

private async Task LoadDatabase()
{
    db = new SQLiteWinRT.Database(
        ApplicationData.Current.LocalFolder, "sqliteperf.db");

    await db.OpenAsync();

    string sql = @"
        CREATE TABLE IF NOT EXISTS TTC 
            (id INTEGER PRIMARY KEY, 
                Route_ID INTEGER, 
                Service_ID INTEGER, 
                Trip_ID INTEGER, 
                Trip_Headsign TEXT,
                Direction_ID INTEGER, 
                Block_ID INTEGER, 
                Shape_ID INTEGER, 
                Wheelchair_Accessible BOOL)";

    await db.ExecuteStatementAsync(sql);
}

Using this code, and by commenting out lines here and there as appropriate, we can test three scenarios:

  • Processing the input file but not inserting records in the database (this just gives us the time for the file processing)
  • Uncomment the call to StepAsync() to Insert each record into the database individually
  • Uncomment the lines executing the BEGIN TRANSACTION, END TRANSACTION statements so all records are inserted inside a single transaction

testrunner  Transaction

And the results? Well, not great, to be honest:

Test Total Time (seconds) – 128982 records Insert Time per record (ms)
Process records – no insert 7
Insert records individually 6307 49
Insert records within a containing transaction 3177 25

Although wrapping all the inserts into a single transaction halves the time it takes to insert the 128982 records compared to separate operations (where the database engine will activate an implicit transaction for every insert), we are still only getting 25ms per insert, or 40 operations per second. That’s not too impressive.

Trying ConfigureAwait(false)

Those performance figures are disappointing and make bulk insert operations in a Windows Phone or Windows Store app impractical. However, look what happens when we make a subtle change to the main loop of code:

Stopwatch sw = Stopwatch.StartNew();
int n = 0;

// Prepare statement
using (var statement = await db.PrepareStatementAsync(
    @"INSERT INTO TTC (id, Route_ID, Service_ID, Trip_ID, Trip_Headsign, 
                        Direction_ID, Block_ID, Shape_ID, Wheelchair_Accessible) 
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"))
{
    // Start transaction
    await db.ExecuteStatementAsync("BEGIN TRANSACTION");

    /*********************************************/
    /* Open input file and import into Database*/
    var inputfile = await Windows.ApplicationModel.Package.Current.
        InstalledLocation.GetFileAsync("trips.txt");
    using (var inputStream = await inputfile.OpenSequentialReadAsync())
    {
        using (StreamReader rdr = new StreamReader(inputStream.AsStreamForRead()))
        {
            while (true)
            {
                string inputline = await rdr.ReadLineAsync();
                if (inputline == null)
                    break;

                // Discard line 0 - header line
                if (n > 0)
                {
                    string[] fields = inputline.Split(new char[] { ',' });

                    Route_ID = Int32.Parse(fields[0]); ;
                    Service_ID = Int32.Parse(fields[1]);
                    Trip_ID = Int32.Parse(fields[2]);
                    Trip_Headsign = fields[3];
                    Direction_ID = Int32.Parse(fields[4]);
                    Block_ID = Int32.Parse(fields[5]);
                    Shape_ID = Int32.Parse(fields[6]);
                    Wheelchair_Accessible = fields[7] == "1" ? true : false;

                    /* Bind parameter values and Insert */
                    statement.Reset();
                    statement.BindIntParameterAt(1, n);
                    statement.BindIntParameterAt(2, Route_ID);
                    statement.BindIntParameterAt(3, Service_ID);
                    statement.BindIntParameterAt(4, Trip_ID);
                    statement.BindTextParameterAt(5, Trip_Headsign);
                    statement.BindIntParameterAt(6, Direction_ID);
                    statement.BindIntParameterAt(7, Block_ID);
                    statement.BindIntParameterAt(8, Shape_ID);
                    statement.BindIntParameterAt(9, Wheelchair_Accessible ? 1 : 0);

                    await statement.StepAsync().AsTask().ConfigureAwait(false);
                }

                n++;
                if (n % 100 == 0)
                {
                    Dispatcher.BeginInvoke(()=>progressBar.Value = n);
                }
            }
        }
    }

    // Commit transaction
    await db.ExecuteStatementAsync("COMMIT TRANSACTION");
}

db.Dispose();
db = null;

Dispatcher.BeginInvoke(() =>
    {
        var report = String.Format(
            "Inserted {0:d} records in {1:0.00} seconds", 
            n - 1, (double)sw.ElapsedMilliseconds / 1000);
        MessageBox.Show(report);

        Button_Start.IsEnabled = true;
    });
}

The main – and significant change above – is that the StepAsync() method is now called in a different way:

await statement.StepAsync().AsTask().ConfigureAwait(false);

In addition, the code that ‘touches’ the UI, such as the MessageBox.Show() call, and the code setting the ProgressBar is now called using Dispatcher.BeginInvoke(Action a). This is necessary because the change to how StepAsync() is called has a knock-on effect of causing the code to end up executing on a background thread – I will explain more on this shortly.

What does this do to the timings?:

Test Total Time (seconds) – 128982 records Insert Time per record (ms)
Process records – no insert 7
Insert records individually 6307 49
Insert records within a containing transaction 3206 25
Insert individually with ConfigureAwait(false) 2791 21
Insert within a transaction with ConfigureAwait(false) 55 0.43

TransactionWithConfigureAwait

WHOA! What happened there? If you insert records within a transaction and use ConfigureAwait(false), you can achieve insert performance of one insert every 0.43 ms, or 2345 records per second. Now we’re talking! That means the performance of inserting records individually without using ConfigureAwait(false) is more than 144 times slower than the best case.

Why such a dramatic improvement? Well, the Task.ConfigureAwait(bool continueOnCapturedContext) method is used to configure the awaiter used to await the result of the asynchronous operation. An awaiter is an object you don’t see or program directly as a developer, but simply by using the await keyword when calling an asynchronous method, the compiler will generate code that uses an awaiter to handle the suspension and reactivation of your calling method while it waits for some asynchronous operation to complete. When the asynchronous method has completed, the awaiter resumes execution of your code which by default happens on the same context (think ‘thread’) you were on when you called the async method. But if you set ConfigureAwait(false), it doesn’t do that but instead continues on whatever context the async method executed on. There’s a performance advantage to this, which is why the advice to authors of library code is that you should always make async calls within your library code using ConfigureAwait(false) – the caller of your library method can then make the decision on whether to return to their original context by choosing whether or not to use ConfigureAwait(false) on the call to your async library method.

Which is what we are doing here – by setting ConfigureAwait(false) on our call to SqlWinRT:Statement.StepAsync() we are saying “don’t bother continue on the originating context, stay on whatever context you are executing on”. And as you can see, the performance gain is spectacular! To be honest, I was very surprised just how spectacular the performance improvement is. Normally, you would expect a modest performance gain, but I guess that because this call is happening between managed code and a WinRT component, the overhead of ConfigureAwait(true) – the default – is particularly significant.

One consequence of using ConfigureAwait(false) is that our code after the await call resumes on a background thread, so when we want to interact with the UI, such as to set the ProgressBar or to display the message at the end, we have to use the Dispatcher to make sure the code that touches the UI executes back on the UI thread:

Dispatcher.BeginInvoke(() =>
    {
        var report = String.Format("Inserted {0:d} records in {1:0.00} seconds", 
            n, (double)sw.ElapsedMilliseconds / 1000);
        MessageBox.Show(report);

        Button_Start.IsEnabled = true;
    });

If we don’t do that, you get an exception.

SELECT Performance

What about the performance of reading records out of the database? The warnings I gave in the introduction to this piece about having appropriate keys configured if you are doing a SELECT with a filter on a column that is not the primary key are still valid. But even if you are simply reading all the records out of a table, whether you use ConfigureAwait(false) again has a huge impact.

Here’s the code you would probably write to read all the rows in our table and to load them into in-memory objects in an ObservableCollection<T> ready to display on the UI:

private async void Button_Select_Click(object sender, RoutedEventArgs e)
{
    if (db == null)
    {
        db = new SQLiteWinRT.Database(
            ApplicationData.Current.LocalFolder, "sqliteperf.db");

        await db.OpenAsync();
    }


    Stopwatch sw = Stopwatch.StartNew();
    int n = 0;
    Button_Select.IsEnabled = false;

    string sql = @"
        SELECT
            id , 
                Route_ID , 
                Service_ID, 
                Trip_ID, 
                Trip_Headsign,
                Direction_ID, 
                Block_ID, 
                Shape_ID, 
                Wheelchair_Accessible
            FROM TTC";
    var stmt = await db.PrepareStatementAsync(sql);

    ObservableCollection<TransportationTrip> tripCollection =
        new ObservableCollection<TransportationTrip>();

    while (await stmt.StepAsync())
    {
        var trip = new TransportationTrip()
        {
            ID = stmt.GetIntAt(0),
            RouteID = stmt.GetIntAt(1),
            ServiceID = stmt.GetIntAt(2),
            TripID = stmt.GetIntAt(3),
            TripHeadsign = stmt.GetTextAt(4),
            DirectionID = stmt.GetIntAt(5),
            BlockID = stmt.GetIntAt(6),
            ShapeID = stmt.GetIntAt(7),
            WheelchairAccessible = 
                stmt.GetIntAt(8) == 1 ? true : false,
        };

        tripCollection.Add(trip);
        n++;
    }

    var report = String.Format("Selected {0:d} records in {1:0.00} seconds",
        n, (double)sw.ElapsedMilliseconds / 1000);
    MessageBox.Show(report);

    Button_Select.IsEnabled = true;
}

Running this gives the following result:

SELECT-no-Await

2838 seconds! That sucks – big time.

Then do it again, but make these subtle changes:

while (await stmt.StepAsync().AsTask().ConfigureAwait(false))
{
    var trip = new TransportationTrip()
    {
        ID = stmt.GetIntAt(0),
        RouteID = stmt.GetIntAt(1),
        ServiceID = stmt.GetIntAt(2),
        TripID = stmt.GetIntAt(3),
        TripHeadsign = stmt.GetTextAt(4),
        DirectionID = stmt.GetIntAt(5),
        BlockID = stmt.GetIntAt(6),
        ShapeID = stmt.GetIntAt(7),
        WheelchairAccessible = stmt.GetIntAt(8) == 1 ? true:false,
    };

    tripCollection.Add(trip);
    n++;
}

Dispatcher.BeginInvoke(() =>
    {
        var report = String.Format("Selected {0:d} records in {1:0.00} seconds", 
            n, (double)sw.ElapsedMilliseconds / 1000);
        MessageBox.Show(report);

        Button_Select.IsEnabled = true;
    });

Which gives this result:

SELECT-await

That’s some improvement! Comparing the two:

Test Total Time (seconds) – SELECT 128981 records SELECT Time per record (ms) Records per second
SELECT 2838 22 45
SELECT with ConfigureAwait(false) 32.4 0.25 3980

That’s a huge improvement!

[WARNING: The timings quoted here are for running on the emulator. You should expect times on a real device to be very substantially slower.]

Conclusions

Some golden rules emerge from this:

  1. Use ConfigureAwait(false) when calling SqlWinRT async methods, particularly within repetitive looping such as INSERT or SELECT of a significant number of records. Remember that when you do so, your code will not resume on the same context it started on, so take appropriate measures to handle this.
  2. In addition to using ConfigureAwait(false), wrap large numbers of INSERTs in a single transaction to get the best performance.

The last learning from this is not specific to SqlWinRT: if you call async methods on a WinRT component, there is a significant overhead in switching back to the originating context. Try calling such a component using ConfigureAwait(false) – it may yield significant performance benefits.

Lastly – this was a test program. If you ever find yourself trying to read 128000 records into memory, I would suggest you have another think about your app design and whether you really need all those objects in memory Smile .

Windows Phone “App to the Future” Design Challenge

Happy New Year to everyone!

We start 2013 with a Windows Phone competition that is being run by Core77, Inc. and Microsoft.

Now You Can Change the Future
Challenge ends February 3, 2013

Design an app for Windows Phone that showcases how to create, connect or impress the pants off your future self. Apps are a way to take control of your day-to-day life. Today they help you wake up, dress, commute, stay on top of news and reach the important people in your life throughout the day, and at their best they help you do things the way YOU want to do them. But what more could your apps do for you tomorrow?

Why wait to find out? REGISTER NOW to design your own App to the Future! Full details: http://apptothefuture.core77.com/

5 WINNERS WILL RECEIVE:

A Microsoft Surface TabletSurfacea Windows Phone 8 device  Windows Phone device and a one year subscription to the Windows Phone DEV CENTER.

App to the Future is an app design competition open to the international design community, challenging entrants to design and mockup conceptual apps for the Windows Phone platform to help with their day-to-day challenges, better connect with their family or friends, or showcase an innovative, new app idea. The goals of Core77 and Microsoft are to showcase and triumph innovative designs through the Core77 Design Network of websites and the Microsoft Windows Phone Store and related websites such as Channel 9. Top winning entrants will be further encouraged to develop and sell their app in the Windows Phone Store utilizing prizes, resources and assistance provided by Core77 and Microsoft.

UK Windows Phone App Developers–’Port Your App to Windows 8’ Competition!

Having just completed the Windows Phone 8 JumpStart, you might think I would be totally focused on helping our developer community to incorporate some of the great Windows Phone 8 features into their phone apps. Well I am Smile – but we also want to focus on the great opportunities awaiting Windows Phone developers if you port your Windows Phone app to Windows 8. As published Windows Phone app developers, you are well-placed with the skills and knowledge of app building you need to create great Windows 8 apps. If your Windows Phone app would work well on a Windows 8 slate or tablet, think about porting your app to Windows 8 now, and you could win great prizes in a promotion we are running up to Christmas!

The Windows Store is open and a new opportunity is here. This is perfect for you as a Windows Phone app builder as you can create even more immersive app experiences, reach more people on more devices, and make more money on your terms. Richard Walter’s Calculator2 app on Windows 8 is now approaching 100,000 downloads after porting it from Windows Phone. More importantly, you already have the development skills needed to make the most of Windows 8. Check out the resources to get started or drop your details and register for a free consultation about building a Windows 8 app. You can port your Windows Phone 7.1 Silverlight apps to Windows 8 XAML, and if you have a game built with XNA you can port those to Windows 8 using MonoGame – see this blog post series for details on how to do that.

If you publish your Windows Phone app on to Windows 8 Store before 25th December 2012, you will go into an exclusive prize draw where you will have the chance to win one of 2 x ASUS VivoTab RT slates. Simply drop an email to ukmsdn@microsoft.com with your contact details and the URL & screenshot of your app in the Windows Store and you will get in the draw. If you can publish more than one app then you increase your chances of winning as you can have one entry per app. Note that terms and conditions apply (see link at the end of this post).

Furthermore, if you get a Windows 8 app in store before Christmas Day (25 Dec, 2012), you will get additional chances of winning great prizes including Windows 8 Slates and PCs. Click here to learn more. We are giving away one amazing 32 GB Windows tablets every day up to Christmas – that’s one lucky winner drawn at random from those who publish a Windows 8 app during this period. We also have the best app competition where 10 x finalists will walk away with a Windows 8 Ultrabook, a Windows tablet and Nokia Lumia 920 Windows Phone 8 device.

I hope you can take advantage of this new and significant opportunity to take your apps from Windows Phone to Windows 8.

Andy

Windows Phone 8 Jump Start Video Recordings now available!

The videos for last weeks’ two days of demo-packed fun that was the Windows Phone 8 Jump Start are now available online. So if you missed the event, or part of it, or were there and want to watch it all over again, you can find them in one of these two places:

On Channel 9:

Here you can find the 21 (count em!) sessions we delivered over the two days, so start at the beginning and settle down to two days of information, or pick out the sessions that interest you, from the following:

Full course outline:

At the Microsoft Virtual Academy:

If you prefer a different way of learning, you can take the Building Apps for Windows Phone 8 Jump Start course at the Microsoft Virtual Academy which includes the same video content, but allows you to track your learning through your dashboard at the MVA, and accumulate points as you take part in the learning. There are also many other courses and Jump Starts you can take part in.

Enjoy!

Mobile Operator Billing now live with 14 operators in 11 countries

In all the wave of Windows Phone news recently, it may have missed your attention that Mobile Operator billing is expanding.

If a user is on one of the mobile operators listed below, the user can make Store purchases using their mobile account. Another way of making it easier for users to purchase Apps, Music and In-App purchase items!

See the current list here . This page will be updated as new MOs are added. Currently, it look like this:

The following table lists the countries/regions and mobile operators where Mobile Operator Billing in Store is currently supported. When you publish your paid applications to these countries/regions, Mobile Operator Billing will be offered automatically as a payment method for users of the specified mobile operators.

Data as of December, 2012

Country/Region Mobile Operators

Australia

Austria

Belgium

Canada

Finland

France

Germany

Mexico

South Korea

United Kingdom

United States

Telstra Corporation

A1 Telekom

Mobistar

Telus Mobility

Elisa Corporation

Orange France

Telekom Deutschland

Telcel

KT Corporation, LG U+, SK Telecom

Everything Everywhere Limited (Orange)

AT&T Mobility, T-Mobile USA

*Postponed* iOS to Windows 8 Live Event!

Windows 8 is all about simplicity, for that reason we have decided to cancel this weekend’s event and combine it with a global event that is taking place in Seattle on the 14th and 15th of December. This 2 day event will start at 5pm on the 14th and will be run by the Big Nerd Ranch, all sessions will be live streamed, so regardless of where you are you can take part.

You can register for the global event here – http://bit.ly/SGddLJ

We still plan to hold a UK based workshop in early 2013, and we’ll ensure you receive plenty of notice as to when this is taking place.

Welcome to my new blog!

Andy WigleyHi, and welcome to the new home of my blog.

I started working for Microsoft as a technical evangelist a few weeks ago. In this blog, I will write on topics that will mostly be tips and techniques to help developers build apps for Windows Phone devices and tablets, slates and other mobile computers running Windows. Two weeks ago, we launched Windows 8 and last week we launched the Windows Phone 8 SDK – what an exciting time to be joining Microsoft!

Before this, I was a proud partner of APPA Mundi, the UK-based mobile consultancy and training company. They are still one of the best companies you can go to if you want to talk to some of the smartest mobile application developers on the planet. My old blog is still where I left it at http://community.appamundi.com/blogs/andywigley and there’s some good stuff on there. I may duplicate some of the most popular posts on here, but please go take a look at that blog as well for posts on .NET development on Windows Phone , Windows Embedded and Windows Mobile.

So, on with the show…