.NET - Red zone : Best practices and latest stuff

Windows Phone 7: Issue with Textblock and Textbox rendering

2011-10-16T17:39:00.001+02:00

There is an issue with Silverlight for Windows Phone if you try to show a Textblock or Textbox with a lot of text. In my current Windows Phone 7 project with have a listbox with comments and with large text sizes (above 3300 in our test cases) we have the effect that the space for the text is rendered but not all characters.

The result looks like this:

This happens if the surrounding container object (for example Grid or Stackpanel) has a defined width and the Textbox or Textblock has the VerticalAlignment set to “Stretch”.

The XAML definition looks like this:

   1:  <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">

   2:              <ListBox x:Name="MainListBox" Margin="0,0,-12,0" ItemsSource="{Binding Items}" SelectionChanged="MainListBox_SelectionChanged">

   3:                  <ListBox.ItemTemplate>

   4:                      <DataTemplate>

   5:                        <StackPanel Margin="0,0,0,17" Width="432" >

   6:                            <TextBlock Text="{Binding LineOne}" TextWrapping="Wrap" Style="{StaticResource PhoneTextExtraLargeStyle}"/>

   7:                            <TextBlock Text="{Binding LineTwo}" TextWrapping="Wrap"

   8:                                       VerticalAlignment="Stretch"

   9:                                       Margin="12,-6,12,0" Style="{StaticResource PhoneTextSubtleStyle}"/>

  10:                        </StackPanel>

  11:                      </DataTemplate>

  12:                  </ListBox.ItemTemplate>

  13:              </ListBox>

  14:   </Grid>

The workaround for this problem is to truncate the text after 3300 characters or don’t use a fix width for the container of the Textbox or Textblock element.

The behaviour is the same in Windows Phone 7.0 and Windows Phone 7.1 projects.

Windows Phone 7–Mango süßsauer

2011-10-15T13:20:00.001+02:00

Mein neuster Artikel in der Mobile Technology ist seit Freitag an den Kiosken erhältlich. Entgegen des Arbeitstitels “Mango süßsauer” geht es hier nicht um asiatische Kochspezialitäten, sondern um eine kurze Darstellung der neusten Features für Entwickler bei Nutzung der Windows Phone Developer Tools 7.1 für die Entwicklung von “Mango”-Apps. Süßsauer deshalb, weil nicht nur die Neuerungen beschrieben werden, sondern auch ein Auge auf noch Ausbaufähiges zur Windows Phone Entwicklung gelegt wird.

Windows Phone 7.5 Mango–it’s on the way

2011-09-27T19:34:00.001+02:00

This morning, at roughly 10 a.m. Pacific time, Microsoft began rolling out the Mango update to phones around the world. Windows Phone 7.5 (aka Mango) has about 500 new features and is a major update for the Windows Phone platform.

Eric Hautala says

”I do want to emphasize that today is just the start. Our plan, as I’ll explain in a moment, is to ramp up delivery gradually—but make the update available to most existing customers within 4 weeks.

I’m sure you have lots of questions about the update process and especially when you’ll be able to install Windows Phone 7.5. Here’s our plan.”

More details see: Windows Phone 7.5 update begins

Windows Phone: New Silverlight toolkit announced

2011-08-07T15:47:00.001+02:00

Good news for Windows Phone developers: it's just been announced that the Silverlight Toolkit for Windows Phone will be getting a Mango update sometime in August.

This update will giving developers just a few extra weeks to tweak their Silverlight extensions before the Marketplace starts accepting Mango apps. No word on the exact changes the new toolkit will contain, but I think Jeff Wilcox will give us some goodies in there.

Windows Phone Mango 80004005 error

2011-07-02T09:41:00.002+02:00

Currently my Mango update for Windows Phone fails with error code 80004005.

Answer from Microsoft:

“This is an error that is still being diagnosed at Microsoft. At this time there is no workaround for it. You should restore your phone to its NODO image and wait until there is a resolution for this problem.”

Some suggestions from Microsoft

On these crash / update issues there are two general approaches that you can try.

1. Try to apply the update using a different desktop / laptop system.

2. If a different system still doesnt' help, then remove any personal data from the device and perform a hard reset. Then try the update process again

MVC3: Combine JavaScript files

2011-06-27T13:46:00.001+02:00

A nice tool on codeplex to combine and minifier several JavaScript files:

Combres - WebForm & MVC Client-side Resource Combine Library – Home

Open the Package Manager Console (Tools > Library Package Manager > Package Manager Console)
In the command window:
- If you work with ASP.NET MVC: enter Install-Package Combres.Mvc
- If you work with ASP.NET WebForm: enter Install-Package Combres

Register Route
This step is only necessary for ASP.NET 3.5 users. ASP.NET 4.0 users can skip to the next step. This step is necessary because there's currently no way to generate/transform/reference different code/config/assemblies for different .NET runtimes with NuGet.

Delete the generated file AppStart_Combres.cs
Remove the reference to the assembly WebActivator
Open global.asax code-behind file
- Import Combres namespace, i.e. using Combres;
- Add this to the first line of either RegisterRoutes() or Application_Start(): RouteTable.Routes.AddCombresRoute("Combres");

Modify Combres.xml

Open App_Data/Combres.xml (this should be auto-created when you install the Combres NuGet package)
Add/remove resource sets, resources etc. as per your need. See this article for more information.

Reference to Combres' resource sets in view

Open any view page (e.g. master page) which need to reference JS/CSS resource sets defined in Combres.xml
Add the followings:

<%= WebExtensions.CombresLink("siteCss") %>  
<%= WebExtensions.CombresLink("siteJs") %>

HTML5: Deprecated Tags

2011-06-26T13:15:00.001+02:00

HTML5 has introduced a lot of new fantastic elements that will be helpful to build better web pages. But the specification also deprecates a few tags that you maybe used in your web pages. So keep them in mind and use the more semantically correct tags or use CSS for styling.

Presentational tags that are deprecated:

basefont
big
center
font
s
strike
tt
u

Also the support for frames has been removed. That means that the following tags are gone:

frame
frameset
noframes

A few other tags are replaced by better options:

acronym replaced by abbr
applet replaced by object
dir replaced by ul

In addition to deprecated tags there are many HTML attributes that are no longer valid:

align
link, vlink, alink and text attributes on body tag
bgcolor
height, width
scrolling on the frame element
valign
hspace, vspace
cellpadding, cellspacing, border on the table tag

Deprecated HTML attributes are:

target for links
profile for head tag
longdesc for img and iframe

If you plan on using HTML5 for your website, be sure to look at this elements and attributes to be compatible with the future and HTML5. You can use http://validator.w3.org to validate your page with the standards.

Windows Phone: Share files with Skydrive on Mango

2011-06-14T10:54:00.001+02:00

“Today, more than 250 million documents are shared through SkyDrive, making it one of the most popular ways to upload, view, edit or share documents on the web. Again, we worked to connect our services to the applications and devices you use every day. You can save your Office documents right to SkyDrive from Office 2010 on your PC and Office for Mac 2011, or you can upload documents from your web browser. Once documents are uploaded, SkyDrive works seamlessly with the Office Web Apps for accessing, editing and sharing docs in your browser or in the desktop client. And, thanks to SkyDrive, OneNote works seamlessly across your PC, phone (OneNote Mobile for Windows Phone and OneNote Mobile for iPhone) and web browser (the OneNote Web App).”

Don’t wait for your cloud - use Hotmail and SkyDrive today on your PC, Mac, or Phone

Windows Phone: Off-thread decoding of images with Mango

2011-06-14T10:01:00.001+02:00

A new blog post in Silverlight Phone Performance team blog about new posibilities of decoding images in a listbox in a background thread per xaml definition with the new property CreateOptions.

For more details see: Off-thread decoding of images on Mango, how it impacts your application ? - Silverlight for Windows Phone Performance team blog - Site Home - MSDN Blogs

Silverlight 5 beta: Issue with Toolkit controls

2011-06-07T11:10:00.001+02:00

With Silverlight 5 beta there is an issue concerning the usage of the Silverlight Toolkit controls. For some of them (in my sample the MenuItem) you get a compile error

“The type or namespace name 'ContextMenu' does not exist in the namespace 'System.Windows.Controls' (are you missing an assembly reference?)”

Oops?! If you use intellisense to select the MenuItem control it exists. So definitively a bug in Silverlight 5. After a quick search a found also a hint in Microsoft Connect: Silverlight Forum: SL5 NumericUpDown control compile error | Microsoft Connect

XAML which produce the error:

<StackPanel>

    <ListBox x:Name="ListBoxTest">

        <toolkit:ContextMenuService.ContextMenu>

            <toolkit:ContextMenu x:Name="contextMenu1">

                <toolkit:MenuItem Header="Test"></toolkit:MenuItem>

            </toolkit:ContextMenu>

        </toolkit:ContextMenuService.ContextMenu>

        <ListBoxItem Content="Listitem 1"></ListBoxItem>

        <ListBoxItem Content="Listitem 2"></ListBoxItem>

    </ListBox>

</StackPanel>

Workaround by setting the Menuitems with code behind:

New XAML:

<StackPanel>

    <ListBox x:Name="ListBoxTest">

        <toolkit:ContextMenuService.ContextMenu>

            <toolkit:ContextMenu x:Name="contextMenu1">

                <!--<toolkit:MenuItem Header="Test"></toolkit:MenuItem>-->

            </toolkit:ContextMenu>

        </toolkit:ContextMenuService.ContextMenu>

        <ListBoxItem Content="Listitem 1"></ListBoxItem>

        <ListBoxItem Content="Listitem 2"></ListBoxItem>

    </ListBox>

</StackPanel>

Code:

public MainPage()

    InitializeComponent();

    var menuitem = new MenuItem() { Header = "My Menu" };

    //menuitem.Click += new RoutedEventHandler(menuitem_Click);

    contextMenu1.Items.Add(menuitem);

Windows Phone: Live tile changes with Mango

2011-06-06T14:47:00.001+02:00

One of the unique features of the platform Windows Phone is the existence of a start page with tiles. Some of the tiles could be “live tiles” with some informations about the state of the Windows Phone app. For instance, a social network app could use the live tile to displays the number of unseen posts. The developer of a Windows Phone app can in the current version change the background image (local or remote image), title of the app and a counter (range 0-99) via Push Notifications.

Changes in Mango

With the new Mango release of Windows Phone we have the following changes:

Possible creation of secondary tiles with deep linking to a URI within your application (with parameters)
Access to your tiles with usage of ShellTile.ActiveTiles
Manipulate the tile appearance directly without push notifications with the StandardTileData class
Each tile now have a back page, which could have a image (remote or local), a separate title and a content text
In combination with the new background agent you can now schedule local tile updates
With the ShellTileSchedule class you can define that your tile image should be updated in the specified interval

Secondary live tiles

Adding a secondary tile to the start screen is done with the help of the ShellTile class. The StandardTileData class is used by tile creation or the tile update to hold the tile data.

// Check the existence of the new pinned tile

var shellTile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("PartnerID=4711"));

if (shellTile != null)

    return;

// Create the tile data with some proeprties

var tileData = new StandardTileData

        BackgroundImage = new Uri("Red.jpg", UriKind.Relative),

        Title = "Secondary Tile",

        Count = 12,

        BackTitle = "Back page",

        BackContent = "This is the back page",

        BackBackgroundImage = new Uri("Blue.jpg", UriKind.Relative)

};

// create the tile at the start screen

ShellTile.Create(new Uri("/MainPage.xaml?PartnerID=4711", UriKind.Relative), tileData);

The pictures used for the live tile must be in PNG or JPG format and have the size of 173x173 pixels PNG or JPG. The properties of the files in the solution have to be set to Content and “copy if newer”. The BackgroundImage or BackBackgroundImage could also be web URLs, than the UriKind Absolute should be used.

Deep Linking

If you use a secondary tile with a other Uri than “/” the NavigationService automatically navigates to the given page. In the NavigatedTo-Event you can access via QueryString to the parameters of the tile (in this case “PartnerID=4711”).

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)

    base.OnNavigatedTo(e);

    if (NavigationContext.QueryString.ContainsKey("PartnerId"))

        // do something here

Updates the tiles

To access a tile the ActiveTiles prooperty of the ShellTile class will be used.

To find the primary tile and update the back content property:

var tileToFind = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString() == "/");

if (tileToFind != null)

    var newTileData = new StandardTileData

            BackContent = "Changes for the back"

};

    tileToFind.Update(newTileData);

To find a secondary tile and make some updates:

Find a tile with a specific parameter or all with a deep link to a page (for example details.xaml"):

// Find the tile we want to update.

var tileToFind = ShellTile.ActiveTiles.FirstOrDefault

    (x => x.NavigationUri.ToString().Contains("PartnerID=4711"));

// If tile was found, then update the Title

if (tileToFind != null)

    var newTileData = new StandardTileData

        Title = textBoxTitle.Text

};

    tileToFind.Update(newTileData);

Delete a pinned tile

Delete a secondary or main tile:

var tileFound = ShellTile.ActiveTiles

    .FirstOrDefault(tile => tile.NavigationUri.ToString().Contains("Details"));

if (tileFound != null)

    tileFound.Delete();

Background worker

With the new concept of Mango to run scheduled background agents you can easily create a local update service for tiles.

Start the background agent with help of the ScheduledActionService class. In my sample I use a PeriodicTask which will be scheduled every 30 minutes to check for updates of the live tiles. More details about scheduled tasks you can find here: Scheduled Tasks Overview for Windows Phone

(1) Add a new SchedulerAgent project to your solution

(2) Start a new PeriodicTask by using the ScheduledActionService

private static void StartPeriodicAgent()

    var periodicTask = new PeriodicTask("PeriodicAgent")

            // The description is required. This is the string that the user

            // will see in the background services Settings page on the device.

            Description = "Periodic task for updating the tile"

};

    // If the agent is already registered with the system,

    // call the StopPeriodicAgent helper method.

    if (ScheduledActionService.Find(periodicTask.Name) != null)

        StopPeriodicAgent();

    ScheduledActionService.Add(periodicTask);

private static void StopPeriodicAgent()

    ScheduledActionService.Remove("PeriodicAgent");

(3) At the Invoke Event of the ScheduledTaskAgent update the tile:

           if (task is PeriodicTask)

               var tileToFind = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString() == "/");

               if (tileToFind != null)

                   var rand=new Random(0);

                   var newTileData = new StandardTileData

                       Count = rand.Next(0,99)

};

                   Debug.WriteLine("Updated " + DateTime.Now.ToShortTimeString());

                   tileToFind.Update(newTileData);

The user have in Windows phone settings page a list of the current running background agents and can stop them.

Windows Phone: ListBox and ScrollViewer performance improvment

2011-06-06T10:15:00.001+02:00

Read some intressting facts from the Windows Phone Performance team blog about performance improvments for the ListBox and ScrollViewer with Mango for Windows Phone: Listbox – ScrollViewer performance improvement for Mango and how it impacts your existing application? - Silverlight for Windows Phone Performance team blog - Site Home - MSDN Blogs

Windows Phone: Mango ProgressIndicator in SystemTray

2011-06-05T10:15:00.001+02:00

With Mango for Windows Phone we have some cool changes for the system tray control. SystemTray is a DependencyObject and because Mango is now running on SL4, DependencyObject can be data bound. The other feature for the System Tray coming with Mango is a ProgressIndicator which can used to display progress on async operations.

More details and sample code about the new ProgressIndicator in the System Tray you can find here: System Tray Progress Indicator - Jaime Rodriguez - Site Home - MSDN Blogs

Data Binding of ProgressIndicator

Sample for programmatically data binding of the ProgressIndicator in the Loaded-Event of the page:

this.Loaded += ( x, y ) =>

        var progressIndicator = SystemTray.ProgressIndicator;

        if (progressIndicator != null)

            return;

        progressIndicator = new ProgressIndicator();

        SystemTray.SetProgressIndicator(this, progressIndicator);

        var binding = new Binding("IsChecked") { Source = this.ProgressIndicatorIsVisible };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.IsVisibleProperty, binding);

        binding = new Binding("IsChecked") { Source = this.ProgressIndicatorIsIndeterminate };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.IsIndeterminateProperty, binding);

        binding = new Binding("Text") { Source = this.ProgressIndicatorText };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.TextProperty, binding);

        binding = new Binding("Value") { Source = this.ProgressIndicatorValueSlider };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.ValueProperty, binding);

} ;

Windows Phone: Mango tombstoning news

2011-06-04T11:35:00.001+02:00

With the Mango update of Windows Phone to Windows Phone 7 many things will be changed. One of them is a better support for mutitasking behaviour of your application. This package consists of new background tasks (a will report about this later) and a new state in the executing model of Windows Phone.

The new state

Until Mango, an Windows Phone app will be tombstoned (=process will be killed), if the user leaves the app with the start menu button and call another application. With Mango Microsoft now introduce a new state for an application: “Dormant”. If there is enough memory left, the Windows Phone OS let the process of your app in memory until a other application process will kick it out. The user can than use the new function “Press and hold the back button for two seconds” to open the Mango fast switch application screen to return to one the dorming apps.

Is it really new?

But this state for your application is not really new. Because today with Windows Phone application development for version 7.0, you have to consider this state also. If you have a long running deactivation process, for example because of serialization, it could be that the user returns quicker back to your application than the deactivation is finished. In that case you have to handle the same behaviour that your old process is still running.

How to handle the revival

To distinguish between a activating of your app after tombstoning or revival you can use the IsApplicationInstancePreserved property of the ActivatedEventArgs in the Activated event of your app in that way:

private void ApplicationActivated(object sender, ActivatedEventArgs e)

    if (e.IsApplicationInstancePreserved)

        ApplicationDataStatus = "application instance preserved.";

        return;

    if (PhoneApplicationService.Current.State.ContainsKey("ApplicationDataObject"))

        ApplicationDataStatus = "data from preserved state.";

        ApplicationDataObject = PhoneApplicationService.Current.State["ApplicationDataObject"] as string;

Because in the case of application revival after the dormant state the constructors of your pages are not run through, you can define a bool variable which indicates in the NavigatedTo-Event if your application was tombstoned or not. It is not a good idea to create a static class with a starting state, which is set during the activating event, because the NavigatedTo of your page could be called earlier than the activated event (in case of long running deactivation, for example).

So best practice is to define a private member IsNewPageInstance, which is set to true within the page constructor.

bool isNewPageInstance = false;

// Constructor

public MainPage()

    InitializeComponent();

    this.isNewPageInstance = true;

In the NavigatedTo-Event we know now, if we have to restore our page state:

private void ApplicationActivated(object sender, ActivatedEventArgs e)

    if (e.IsApplicationInstancePreserved)

        ApplicationDataStatus = "application instance preserved.";

        return;

    if (PhoneApplicationService.Current.State.ContainsKey("ApplicationDataObject"))

        ApplicationDataStatus = "data from preserved state.";

        ApplicationDataObject = PhoneApplicationService.Current.State["ApplicationDataObject"] as string;

Testing of Tombstoning with the emulator

Another greeat new feature of the new Mango Windows Phone tools is that you can force the debugger to produce a tombstoning behaviour. The achieve this, you have to check a checkbox in the project properties of the debugging area.

Conclusion

With the new state “dormant” and the fast switching ability of the Windows Phone OS for the Mango version in combination with the new backgound tasks Microsoft give us the tools of trade to emulate a better multitasking appearance. This behaviour is now similiar to other mobile plattforms and still assure a good battery life time. For me, a great step in the right direction.

Windows Phone: Mango Turn-By-Turn Navigation

2011-06-02T12:01:00.001+02:00

One of the cool new features of the Windows Phone 7 Mango release (Windows Phone 7.5) is the posibility to use turn by turn navigation with voice guidance. This feature of Windows Phone Mango is integrated in the standard Bing Maps application and can use by developers from their own Windows Phone apps by the BingMapsDirectionsTask.

In my sample I have added two GeoCoordinate objects. One with my home place and the other with my working place at SDX AG. With the common concept of Windows Phone for interaction by using a Launcher or Chooser task you can then create a BingMapsDirectionsTask instance, set the locations as LabeledMapLocation to the start respectively end property of the BingMapsDirectionsTask and call the Show()-Method.

After this your application put in the background and the standard Bing Maps application will be called. Now you can use the standard turn by turn navigation features with voice guidance.

Conclusion

The new BingMapsDirectionsTask and turn-by-turn navigation features of the Bing Maps application of Windows Phone is a very cool function which will enable developers to build a new kind of Windows Phone applications. Furthermore all applications like “Where is my next bank or letter box” now can give the user the ability to give navigating instructions to this place.

Sample Code

private readonly GeoCoordinate destination;

private readonly GeoCoordinate target;

// Constructor

public MainPage()

    InitializeComponent();

    destination = new GeoCoordinate(49.907903, 8.510628); // Home

    target = new GeoCoordinate(50.139836, 8.742199); // SDX AG

private void NavigateButtonClick(object sender, RoutedEventArgs e)

    var bingMapsDirectionsTask = new BingMapsDirectionsTask();

    var destinationLocation = new LabeledMapLocation(

        "Home",

        destination);

    var targetLocation = new LabeledMapLocation(

        "SDX AG",

        target);

    bingMapsDirectionsTask.Start = destinationLocation;

    bingMapsDirectionsTask.End = targetLocation;

    bingMapsDirectionsTask.Show();

Silverlight 5: Better MVVM support

2011-05-20T15:10:00.001+02:00

With Silverlight 5 you have the posibilty to define Custome Markup Extensions. For example you can define a new extension MethodInvoke which calls the named method in your datacontext in this way. Not longer event triggers or something else necessary.

more information about Silverlight 5 Beta features: Here

Windows Phone 7- Fiddle Web traffic

2011-05-20T11:24:00.001+02:00

Here is a nice solution for debugging Windows Phone 7 device network traffic with Fiddler. I tested this also using Intel My WiFi Technology instead of Connectify.

http://dotnetbyexample.blogspot.com/2011/05/debugging-windows-phone-7-device.html

Windows Phone 7: Update for Windows Azure Toolkit

2011-05-16T17:01:00.001+02:00

Microsoft has now released the third update of the Windows Azure Toolkit for Windows Phone in less than two months – shows that they are hard working on good Windows Azure support for Windows Phone.

One of the new features is the support for Windows Azure Access Control Services.

More details here: Update to Windows Azure Toolkit for Windows Phone 7 « Michael S. Collier's Blog

Silverlight 5 goes to desktop application platform

2011-05-15T12:38:00.001+02:00

With the new version Silverlight 5 (beta available) the sandbox of an Silverlight app will be nearly destroyed. If you run your Silverlight application in elevated trust mode as out-of-browser application you can access now to the whole local file system and using P/Invoke to call a Win32-Api function. This will give us as developers a total new scope for Silverlight applications. We can now concept Silverlight applications that have native access to local resources like scanners, 3rd party applications and the whole file system – I love this, because the necessity of using WPF nearly disappears.

Pete Brown give us a flavour of new Silverlight applications that uses several operating windows:

Silverlight 5: Working with Operating System Windows - Pete Brown's 10rem.net

Windows Phone 7– A taste of Mango for developers

2011-05-15T12:22:00.001+02:00

The Mango update for Windows Phone 7 was announced at the Mix11 for end of 2011. But the capabilities of Mango are coming a little bit earlier to developers next month with the new Windows Phone tools.

Jese Liberty has now published a few code samples and decriptions for a few key features that will come with Mango.

SQL Server CE

Coming in Mango–Sql Server CE | Jesse Liberty

Access to Calendar and Contacts

Coming in Mango–Query the Contacts List | Jesse Liberty

Silverlight 4 as the new base brings

Coming in Mango–Implicit Styles | Jesse Liberty

Coming In Mango–ICommand | Jesse Liberty

Notifications - Reminders and Alarms

What’s Coming In Mango–Reminders | Jesse Liberty

Windows Phone 7–the importance of ? for web service calls

2011-05-15T12:01:00.001+02:00

In an older blog post I have mentioned that Windows Phone uses some magic caching mechanism if you call a web service with the same Uri. Because I have the problem now again with a REST-service in my new demo app, I will explain a possible workaround for this caching behaviour a little more in detail.

The problem

For example the call of the RESTfull service TopList

http://localhost:57988/BornToMoveService.svc/TopList

will not invoked by your Windows Phone 7 client if you call this service a second time. The Windows Phone OS caches the service calls and will give you back the same results as after your first call. For example the event wc.DownloadStringCompleted of the WebClient class the same results as after your first call.

If you now will have the idea to destroy your instance of your WebRequest or WebClient class to force a non-caching behaviour – dont’t waste your time. The caching behaviour is still there.

The solution

The only way to get rid of this caching behaviour is to add a unique sign at your Uri. In this sample I use a Guid and put it after the normal REST-Url.

public void LoadData()

    ReadJsonDataAsync<TopListEntry>(BaseUrl + "TopList", list => this.TopList = list);

private static void ReadJsonDataAsync<T>(string url, Action<ObservableCollection<T>> resultAction)

    var wc = new WebClient();

    wc.DownloadStringCompleted += (s, e) => OnReadJsonDataCompleted(e.Result, resultAction);

    wc.DownloadStringAsync(new Uri(url+ "?id="+ Guid.NewGuid().ToString()));

Android apps with C#

2011-04-17T15:08:00.001+02:00

Developing Android apps with C# and.NET technologies?

What sounds strange is now possible with Mono for Android 1.0 (short: Monodroid), recently published by Novell. With Monodroid you can develop applications for Android-Smamtphones with Visual Studio 2010. Mono 1.0 is thereby fully integrated in Visual Studio 2010. The corresponding APIs for the Dalvik engine have been adjusted for C#, also the JIT compiler is fully usable. In addition, the use of F# and IronJS and partly also IronPython and Ironruby with Monodroid should be possible.

Windows Phone 7: Mango Update

2011-04-17T14:18:00.001+02:00

From Windows Phone "Mango" Preview a good summary of the coming features for Windows Phone 7 with the “Mango” Update:

Assuming they actually hit this schedule, Microsoft will release a major update to Windows Phone, internally called Windows Phone 7.5 (though that could change) and codenamed "Mango," sometime in the final quarter of 2011. Mango will be made available for free to all current Windows Phone handset owners, but my suspicion is that the best experience will be had on a second generation of new devices that include additional capabilities not found in today's phone. Microsoft first officially unveiled Mango earlier this year, but they provided a lot more information about this release this month at its MIX'11 conference. So I'd like to highlight what we know about Mango so far, with the understanding that things will no doubt change going forward. Indeed, there are many consumer- and business-oriented features coming in Mango that Microsoft has yet to discuss publicly.

New minimum hardware specifications

One of Windows Phone's most heralded changes from its Windows Mobile predecessor was that the new system would have a much more tightly controlled hardware specification, which Microsoft said would prevent a proliferation of divergent devices that would be very hard to update. I'll pause while you consider the ensuing irony--Microsoft has had nothing but trouble updating the first generation of nearly identical Windows Phones--but it's a good idea regardless.

Oddly, the first generation of Windows Phone hardware allowed for two so-called chassis specifications, the Chassis-1 that we all know and love (800 x 480 touch screen and so on) and then a separate Chassis-2 spec that has never materialized into an actual shipping piece of hardware; this one was to have supported smaller 480 x 320 screens with a hardware keyboard and it was, put simply, Microsoft's version of a Blackberry.

The Chassis-2 spec is dead, and there won't be any phones released with those specifications. Instead, Microsoft is rallying around an updated version of the Chassis-1 spec for Mango. And the specs have changed just a bit since the first generation:

Processor. Whereas the original specification called for 1 GHz or faster ARMv7 Cortex/Scorpion (Snapdragon) or better processor, the new spec calls for second generation Qualcomm ARMv7 (MSM8x55 or MSM7x30) processors, running at 800 MHz or higher. So 1 GHz is no longer the baseline. That's because a new generation of processors with lower clock speeds is both cheaper to make and powerful enough to handle Windows Phone OS, according to Microsoft. But this represents the platform's first foray into the non-luxury end of the market, paving the way for comparatively low-end Windows Phone handsets. (This is something Nokia demanded, but this work was in progress some time ago.)

GPU. As with the first generation devices, Mango-era phones will ship with a DirectX 9-capable graphics processing unit, or GPU. But the Adreno 205 is replacing the earlier Adreno 200 part.

Gyroscope. Mango will support a hardware gyroscope, a feature that was not part of the first generation Windows Phone spec. And in an interesting and related move, no non-supported sensors will be allowed.

What hasn't changed? Most of the spec, actually. All Windows Phones will still ship with capacitive multi-touch screens with 4 or more contact points. A-GPS, accelerometer, compass, light, and proximity sensors. A 5 megapixel or better camera. 256 MB of RAM or more and 8 GB of Flash storage or more. (Most handsets do ship with 512 MB of RAM, Microsoft says, though 8 GB is sadly the default storage capacity.) And three hardware buttons, arrayed in the same layout: Back, Start, and Search. Most dramatically, perhaps, 800 x 480 is the only supported screen resolution for Windows Phone now.

Updated software architecture

With the initial version of Windows Phone 7, the underlying operating system was simply called Windows Phone 7. Now, it's being renamed to Windows Phone OS to obfuscate the versioning (since Mango is version 7.5) and make the branding more obvious. (That is, you have a Windows Phone device running Windows Phone OS.)

Where Windows Phone 7 was based on Silverlight 3 and XNA 3, Mango is based on Silverlight 4 and XNA 4 and supports, for the first time, integration between the two. (In WP7, Silverlight was generally just used for apps and XNA was generally just used for games. Now developers can mix and match.) Silverlight 4 brings improved user interface controls and a Clipboard API for third party copy and paste support, as well as some needed performance improvements.

Windows Phone 7 included Windows Live ID, Xbox LIVE, and Bing integration, and Mango extends those with better location and notification services. And dramatically better support for Asian languages should improve Windows Phone's popularity in international markets.

Multitasking of third party apps

One of the big misconceptions about Windows Phone 7 today involves multitasking. That is, Windows Phone 7 does support full multitasking capabilities, albeit only for those apps that come bundled with the OS. In Mango, multitasking is being opened up for third party apps, and as with Apple before it, Microsoft has come up with a scheme that should work well while preserving battery life and not making the user experience more complex.

At the heart of this system is a new software construct called an agent, so multitasking efficiently may require some app rewriting. This agent is essentially a subset of an app's core logic, and it can run separately from the app's UI, and thus still be running in memory when the user switches to a different app.

And regardless of agents, Mango will support new fast app resume functionality because apps can stay in memory unless that memory is needed for other apps. So switching back and forth between apps should always be faster.

Background tasks

There are a couple of Mango features related to the multitasking infrastructure. The first is background task support.

For example, in Windows Phone 7, only the built-in Zune software provided background audio playback support. Now, third party audio apps-Pandora, Last.FM, whatever--can keep playing in the background too, and utilize the same pop-up notification UI for media control.

Second, Mango will support background transfers for apps that need to perform downloads.

Push notifications

Also related to multitasking is the ability of third party apps to create alarms and reminders. So apps perform background file transfers, for example, could optionally display a toast notification or tile update at the end of the transfer so the user is aware of what happened.

Tiles

Windows Phone's live tiles are, perhaps, one of the platform's biggest differentiators. Instead of providing static icons, as on the iPhone, Windows Phone apps can provide big, expressive, and dynamic tiles that respond and react to notifications and other changes. In Mango, tiles are getting even more intelligent. Developers will be able to create multiple tiles for a single app, for example, and provide "in-app" tiles that are tied to a specific feature and not just to the app generally.

The example: A flight tracker app where you may want to pin one or more individual flights, each with its own notifications, right to your Home screen. Microsoft calls this feature "deep toast" because the original system notifications were called toast, because they appear like slices of toast out of a toaster.

Microsoft is also increasing the number of live tiles you can add to the Home screen from 15 to 30, and tiles can now flip to provide a secondary display on the "back" of the tile.

Internet Explorer 9

Windows Phone Mango will include a new version of the Internet Explorer 9 Mobile web browser that provides hardware acceleration and utilizes the renderer from the desktop version of IE 9. This should dramatically improve the browsing experience on Windows Phone, of course, and increase compatibility with existing sites. And if Microsoft's performance demos are to be believed, IE 9 Mobile will blow the mobile browsers on Android and iPhone out of the water.

Responding to user complaints, Microsoft has also streamlined the IE 9 user experience and now provides a combined app bar and address bar in landscape mode as well.

Twitter

Where Windows Phone 7 included Facebook account integration out of the box, Mango adds Twitter account integration as well. (This feature was originally scheduled for the initial release of the platform, but Microsoft and Twitter had a falling out that has since been resolved.) As with Facebook, Twitter account information will be integrated into the People hub.

New Extras

In the initial version of Windows Phone 7, Microsoft provided third party app access to the Music + Videos and Pictures hubs, via a hard to find "ghetto" area called Extras (or Marquee). In Mango, these capabilities continue in enhanced form, and Microsoft is letting third party apps also tie into Bing via the new Search Extras functionality. This will be exposed in a similar to manner as the existing functionality (i.e. in a hard to find Extras area with Bing search results). And third parties can create Search Extras in just four result type areas: Movies, Places, Events, and Products.

Database services

One of the weird developer-oriented limitations in the original shipping version of Windows Phone 7 was the lack of any on-device database support. This is changing in Mango, of course, with the addition of the SQL Compact Embedded (CE) database, which developers will access solely through LINQ, a way of abstracting database access. Put simply, the use of LINQ means that Microsoft can optimize the low-level database as needed and, if required in the future, actually swap it out for a better-performing replacement.

Additionally, Microsoft is also allowing third party apps to seamlessly access the People (contacts) and Calendar data stores as well.

Sensor and camera access for third party apps

While developers could target the accelerometer in the initial version of Windows Phone, Mango adds developer access to two new sensors, the compass and the gyroscope. Additionally, there is a fourth "virtual" sensor called the Motion sensor that uses the other three physical sensors on the device to calculate movement (or two if your phone doesn't have a gyroscope).

Microsoft is also providing raw Camera access to developers so it's possible that third parties will create full-featured camera apps to replace the terrible (and settings adverse) version that comes stock with Windows Phone.

Networking features

Microsoft is adding various new networking features to Mango, including sockets support and Connect Manager control for third party apps. Sockets is arguably the big deal here: It will allow applications like Skype to appear on Windows Phone for the first time.

Developer tools improvements

With over 1500 new APIs coming in Mango, developers are going to want to get up to speed with this upcoming release as quickly as possible. And on that note, beta versions of the Mango-era developer tools will ship in mid-May, Microsoft says. And they're coming with a lot of new features, many of which, of course, target new Mango features. The emulator will now emulate some sensors, like the accelerometer and location sensor, for example, and will add other enhancements like full media support. Developers will be able to target multiple hardware devices when building apps, for easier testing, and an improved profiler is being added to the free version of the tools too, so developers can figure out why their apps run so slow.

Windows Phone 7 - Nodo Update Gotcha

2011-03-30T21:40:00.001+02:00

After reading some blogs about forcing the NoDo Update for Windows Phone 7, I had today the idea to deactivate the data connection and wlan at my HTC Mozart. After I have done this and I connected my phone via USB to my notebook – Surprise, surprise: The message for the NoDo Update appears.

After this I activated the celluar data connection again and everything goes his normal way. After 15 minutes with backup and installation I had the NoDo update on my phone.

Windows Phone 7: Metro design guide for developers

2011-03-26T10:30:00.001+01:00

Here is a very cool guide for developers of Metro design for Windows Phone 7: Jeff Wilcox – Jeff Wilcox’s “Metro” design guide for developers, v1.00

Windows Phone 7: Touch behaviour for every control

2011-03-24T18:18:00.001+01:00

Some controls at Silverlight for Windows Phone does not have any touch behaviour. I you have the need to implement this, the following sample code show you a good way:

Windows Phone: Touch | Jesse Liberty

WP7: WPConnect Tool for debug wo zune

2011-03-24T18:10:00.001+01:00

Using the device debugger with a zune connection is a great advantage of Windows Phone 7 development. But if you want to test some choosers ( for example the PhotoChooserTask) you can not do this with a running zune connection.

Fortunately there's a tool that solves the problem by removing the need to have the Zune software running while debugging. It's called the Windows Phone Connect Tool. It was released as part of the recent update to the Windows Phone Developer Tools. This tool allows you to close the Zune software, after your phone device is connected. After this it is possible to debug choosers such as the PhotoChooserTask.

Here you can get a batch file to do the work for you:

Daniel Vaughan | A Batch File for Closing Zune and Launching the WPConnect Tool

Artikel in dot.net-Magazin 4.2011

2011-03-09T22:25:00.001+01:00

Mein Artikel “Windows Phone 7 – Alles unter Kontrolle” mit einem Überblick über die Windows Phone 7 Controls und deren Einsatz ist jetzt im dot.net-Magazin 4.2011 erschienen.

SQL Server 2008–Recompile all Stored Procedures

2011-02-23T18:57:00.001+01:00

Just a useful script to recompile and check all Stored Procedures in a SQL Server Database, if you have done a lot of refactoring.

declare @Schema_Pattern nvarchar(776) = NULL -- Owner name Pattern for Like, Null for all

declare @Proc_Name_Pattern nvarchar(776) = Null -- Proc Pattern for Like, Null for all

SET NOCOUNT ON

-- First do the user databases specified in the control table DECLARE ProcCur CURSOR READ_ONLY FOR

            SELECT ROUTINE_SCHEMA

              , ROUTINE_NAME

            FROM INFORMATION_SCHEMA.ROUTINES

            WHERE 0=OBJECTPROPERTY(object_id(ROUTINE_SCHEMA + '.'

                                     + ROUTINE_NAME), 'IsMsShipped')

                        AND ROUTINE_TYPE = 'PROCEDURE'

                AND (@Schema_Pattern IS NULL

                       OR ROUTINE_SCHEMA LIKE @Schema_Pattern)

              AND (@Proc_Name_Pattern IS NULL

                       OR ROUTINE_NAME LIKE @Proc_Name_Pattern)

DECLARE @Owner nvarchar(776)

      , @Proc  nvarchar(776)

      , @SQL   nvarchar(4000)

      , @NumP  int

      , @NumE  int

      , @myError int

      , @myRowcount int

SELECT @NumP = 0 , @NumE = 0

OPEN ProcCur

FETCH NEXT FROM ProcCur INTO @Owner, @Proc

WHILE (@@fetch_status <> -1) BEGIN

    IF (@@fetch_status <> -2) BEGIN

        SELECT @SQL = 'exec sp_recompile ''' + @Owner + '.' + @Proc + ''''

        PRINT 'Running: ' + @SQL

        EXEC (@SQL)

        SELECT @myError = @@Error

        IF @myError = 0 BEGIN

              SET @NumP = @NumP + 1

END

        ELSE BEGIN

             PRINT 'Error Marking ' + @Owner + '.' + @Proc + ':' + convert(varchar(20), @myError)

             SET @NumE = @NumE + 1

END

END

   FETCH NEXT FROM ProcCur INTO  @Owner, @Proc END

CLOSE ProcCur

DEALLOCATE ProcCur

Mobile Technology WP7 unter Kontrolle

2011-02-17T21:01:00.001+01:00

Heute ist in der Mobile Technology in der Ausgabe 01.2011 mein neuester Windows Phone 7 Artikel erschienen.Der Artikel gibt einen Überblick über die Windows Phone 7 Controls, zeigt Unterschiede zur Handhabung gegenüber den normalen Silverlight Controls und gibt wichtige Nutzungshinweise zu deren effektiven Einsatz.

Silverlight set initial Focus / Focus popup or ChildWindow

2011-02-08T15:00:00.001+01:00

In our current project we had the problem, that we cannot set the Focus to a Control in an initial Login-Dialog (ChildWindow). We try some things like setting the Focus after the Loaded- or PageUpdated-Event – but nothing helps.

After some time of additional research we found out, that the original problem was the missing Focus of the Silverlight Plugin after starting the Silverlight application.

So first step we do this (“HtmlPage.Plugin.Focus” is the magic):

var loginView = new LoginRegistrationView();

loginView.Show();

HtmlPage.Plugin.Focus();

After this, we can use the GotFocus-Event of our Login-Form to set the Focus to the UserName-Field of the DataForm at our Login-Form-ChildWindow.

public LoginForm()

    InitializeComponent();

    this.GotFocus += this.LoginFormGotFocus;

private void LoginFormGotFocus(object sender, System.Windows.RoutedEventArgs e)

           if (this.firstCall)

               var userNameTextBox = (TextBox)loginDataForm.Fields["UserName"].Content;

               userNameTextBox.Focus();

               this.firstCall = false;

Windows Phone 7 Update Troubleshooting

2011-01-30T12:07:00.001+01:00

We all waiting for the NoDo-Update – some sources announce the update around the 7th of February. But Microsoft looking forward and have now published a knowledge base article about troubleshooting problems during the update process of Windows Phone 7 (hope that there are not a lot of)

Troubleshooting problems during software update for Windows Phone 7

Windows Phone 7: GPS emulator

2011-01-29T10:09:00.001+01:00

In your Windows Phone device you have a built-in Assisted GPS (aGPS), which can be used to access location informations by using the System.Device.Location namespace. The GeoCoordinateWatcher class supplies location data based on latitude and longitude coordinates. This is nice, but if you want to develop such an application it is necessary to emulate the GPS sensor.

In this Windows Phone Team Blog a very good article can be found to achieve this goal.

Debugging Windows Phone 7 device traffic with Fiddler

2011-01-18T10:43:00.001+01:00

Eric Law on his MSDN blog has detailed a method using Fiddler to watch your phone's data traffic over WiFi (so this won't help with that 3G issue). Primarily this is a great tool for developers to make sure their app is not using excess data in any way but it can also be useful for those who just want to know what's going on.

Debugging Windows Phone 7 device traffic with Fiddler - Fiddler Web Debugger - Site Home - MSDN Blogs

Data Access with Windows Phone 7

2011-01-17T20:04:00.001+01:00

My article in the german Dotnetpro magazine about data access with Windows Phone 7, I have written with my SDX colleage Matthias (see Mind-driven development), is now out: http://bit.ly/hzYWFC

Windows Phone recipes – Open source projects

2010-12-14T15:23:00.001+01:00

Windows Phone recipes are open source (MSPL) projects aimed at helping Windows Phone developers with their Windows Phone applications. Recipes are usually common patterns for topics that require some attention. The idea is to provide a sample with some reusable code that can be reused later and modified to fit other similar scenarios. Developers are more than welcome to use them as is, or to change them as they see fit.

Windows Phone Recipes – Helping the Community

Windows Phone 7: Grid style listbox

2010-12-11T11:16:00.001+01:00

If you want to implement a grid for your Windows Phone 7 app you have to use a Listbox control because of the missing DataGrid at the Windows Phone 7 platform. A first idea for contsructing a Grid then could be to use the WrapPanel control in your ItemTemplate of the Listbox control. But if you do this, the data virtualization of the ListBox will be disabled (Virtualizing Data in Windows Phone 7 Silverlight Applications - Peter Torr's Blog - Site Home - MSDN Blogs). This will increase the loading time of your ListBox and results in a very poor UX handling. The problem is, that you can not use any complex data structures in the ItemTemplate at a Listbox for Windows Phone 7. Every line in the Listbox should be one data line. So a solution for developing a grid styled Listbox is to implement a RowAdapter class for your bounded data.

Here a implementation of a RowAdapter, I used in one of my projects:

public class RowAdapter<TItemType> : IList<IEnumerable<TItemType>>, INotifyCollectionChanged

        private readonly IList<TItemType> _sourceList;

        private readonly int _columns;

        private class RowObject : IEnumerable<TItemType>

            internal readonly RowAdapter<TItemType> Parent;

            internal readonly int StartIndex;

            public RowObject(RowAdapter<TItemType> parent, int startIndex)

                Parent = parent;

                StartIndex = startIndex;

            #region IEnumerable<TItemType> Members

            public IEnumerator<TItemType> GetEnumerator()

                int limit = Parent._sourceList.Count;

                int end = Math.Min(StartIndex + Parent._columns, limit);

                for (int pos = StartIndex; pos < end; ++pos)

                    yield return Parent._sourceList[pos];

            #endregion

            #region IEnumerable Members

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

                return GetEnumerator();

            #endregion

        public RowAdapter(IList<TItemType> sourceList, int columns)

            if (null == sourceList)

                throw new ArgumentNullException("sourceList", Resource.RowAdapter_RowAdapter_sourceList_is_null);

            if (columns <= 0)

                throw new ArgumentOutOfRangeException("columns", Resource.RowAdapter_RowAdapter_ColumnsGreaterOne);

            // We require the source list to implement IList because we

            // need to know how many item there are

            _sourceList = sourceList;

            _columns = columns;

            var sourceNotify = sourceList as INotifyCollectionChanged;

            if (null != sourceNotify)

                sourceNotify.CollectionChanged += OnSourceCollectionChanged;

        #region IList<IEnumerable<TItemType>> Members

        public int IndexOf(IEnumerable<TItemType> item)

            var realItem = item as RowObject;

            if (null == realItem || !ReferenceEquals(realItem.Parent, this))

                return -1;          // It does not belong to this collection

            Debug.Assert(0 == realItem.StartIndex % _columns, "RowObject item has a wierd index");

            return realItem.StartIndex / _columns;

        public void Insert(int index, IEnumerable<TItemType> item)

            throw new NotSupportedException();

        public IEnumerable<TItemType> this[int index]

get

                if (index < 0 || index > Count)

                    return null;

                return InternalGetRow(index);

set

                throw new NotSupportedException();

        public void RemoveAt(int index)

            throw new NotSupportedException();

        #endregion

        #region ICollection<IEnumerable<TItemType>> Members

        public void Add(IEnumerable<TItemType> item)

            throw new NotSupportedException();

        public bool Contains(IEnumerable<TItemType> item)

            var realItem = item as RowObject;

            return null != realItem && object.ReferenceEquals(realItem.Parent, this);

        public void CopyTo(IEnumerable<TItemType>[] array, int arrayIndex)

            // I haven't implemented this. It is easy to implement if you need it

            throw new NotImplementedException();

        public bool Remove(IEnumerable<TItemType> item)

            throw new NotSupportedException();

        public void Clear()

            throw new NotSupportedException();

        public int Count

get

                return (_sourceList.Count + (_columns - 1)) / _columns;

        public bool IsReadOnly

            get { return true; }

        #endregion

        #region IEnumerable<IEnumerable<TItemType>> Members

        public IEnumerator<IEnumerable<TItemType>> GetEnumerator()

            for (int i = 0; i < Count; ++i)

                yield return InternalGetRow(i);

        #endregion

        #region IEnumerable Members

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

            return GetEnumerator();

        #endregion

        #region INotifyCollectionChanged Members

        public event NotifyCollectionChangedEventHandler CollectionChanged;

        private void FireCollectionChanged()

            var handler = CollectionChanged;

            if (null != handler)

                handler(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));

        private void OnSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)

            FireCollectionChanged();

        #endregion

        private RowObject InternalGetRow(int index)

           return new RowObject(this, index * _columns);

Windows Phone 7: Some links

2010-12-10T10:26:00.001+01:00

Marketplace Reporting is available and first payements will start: Marketplace: Reporting ist da, erste Zahlungen im Januar - LIFE IN MOTION - Site Home - MSDN Blogs
Activate more than three developer devices for a Marketplace account: WP7: Mehr als 3 Entwicklergeräte freischalten–wie? - LIFE IN MOTION - Site Home - MSDN Blogs
How to detect if Zune is running during ChooserTasks: Kodierer [Coder]: Windows Phone Unplugged - How to Detect the Zune Software - Rene Schulte - Coding .Net and Silverlight with C#
Some nice Windows Phone 7 tutorials: eugenedotnet blog | All about Windows Phone 7 and other Microsoft technologies.
Windows Phone 7 and Cloud Connection: Windows Phone 7 Developer Guide

Traps of Windows Azure Development

2010-12-03T10:10:00.001+01:00

My personal traps of Windows Azure development for this week are:

Problems with long project names (longer 248) for the temporary name of my delivery package for running at the Windows Azure emulator
- Use _CSRUN_STATE_DIRECTORY as environment variable to shorten the path
Remove PlatformTarget from an existing Web project file to avoid compile error
- see Hosting Silverlight Application with RIA Services as Cloud Service | .NET - Red zone : Best practices and latest stuff
Strange CommunicationObjectFaultedException error if you use a Source Safe tool and your web.config is read only
If you use assemblies that are not content of a normal Windows Server 2008 SP2 installation (for example RIA Services), you have to set the properties “Copy Local” to true of the assemblies involved – otherwise you get a never ending “busy” state of your web role at Windows Azure Management Tools

Windows Azure: CommunicationObjectFaultedException

2010-12-03T10:02:00.001+01:00

If your web.config is read only you get maybe the following strange error message in a Windows Azure project at runtime. It costs my half a day to find out, that this has nothing to do with my web service configuration or web service usage.

Hosting Silverlight Application with RIA Services as Cloud Service

2010-12-01T13:43:00.001+01:00

We have an existing web project (Silverlight 4, WCF RIA Services) that we wanted to bring to the cloud using Windows Azure. We added a new project, Windows Azure Cloud Service and added a new Web Role. After this you can connect your existing web project to this web role. The isolated web project compiles fine, but our new solution brings the following compile error:

“Error 1 The "CreateRiaClientFilesTask" task failed unexpectedly.System.Web.HttpException (0x80004005): Could not load file or assembly 'msshrtmi' or one of its dependencies. An attempt was made to load a program with an incorrect format. ---> System.Configuration.ConfigurationErrorsException: Could not load file or assembly 'msshrtmi' or one of its dependencies. An attempt was made to load a program with an incorrect format. ---> System.BadImageFormatException: Could not load file or assembly 'msshrtmi' or one of its dependencies. An attempt was made to load a program with an incorrect format.”

Strange, what happens and what can we do?

The solution is very easy, but hard to find out: You have to unload your .web project (which hosts the Silverlight application) and edit it the project file. If you now remove the tags

    <PlatformTarget>AnyCPU</PlatformTarget>

from the project file, your solution can be compiled !

Windows Phone 7: Customize live tiles, push notification

2010-11-28T13:30:00.001+01:00

Found a good article of Chris Koenig about customizing the tiles with Windows Phone 7 Push Notification Services:

Customizing WP7 Push Notification Tiles « Development « Chris Koenig

Windows Phone 7: Recording the microphone

2010-11-22T13:54:00.001+01:00

Description and sample project for recording something with the Windows Phone 7 microphone.

Writing a Proper Wave File - CodeProject

Windows Phone 7: Video Player with MVVM pattern

2010-11-22T13:52:00.001+01:00

If you plan to implement a video player for Windows Phone 7 you could found a good solution using the MVVM pattern here: Windows Phone 7 View Model Style Video Player - CodeProject

Windows Phone 7: Create custom Pushpin for Bing maps

2010-11-21T12:47:00.001+01:00

Good article about creating a custom Pushpin for Bing maps, that I used for my Runner’s app:

How to Create a Custom Pushpin Control Template in Expression Blend for Windows Phone 7 Bing Maps - Nick Harris .NET

Windows Phone 7: No forward navigation

2010-11-19T14:07:00.001+01:00

Information forward navigation at Windows Phone 7:

Navigation Stack on Windows Phone 7 - Peter Foot - APPA Mundi

“While Windows Phone uses the same NavigationService and page-based model as “regular” Silverlight, one area the documentation doesn’t make clear is that although the APIs seem to support both Back and Forward navigation in reality there is no forward navigation on Windows Phone. This means when you navigate to a new page and then return Back to the previous page you can’t call NavigationService.GoForward() to return. CanGoForward will always return False. In the documentation for System.Windows.Controls.Frame (the base class of PhoneApplicationFrame) GoForward is described as:-

“Navigates to the most recent entry in the forward navigation history, or throws an exception if no entry exists in forward navigation. For Windows Phone this method will always throw an exception because there is no forward navigation stack.”

(my use of bold)”

Windows Phone 7: Handle Back button for a open popup

2010-11-17T21:11:00.001+01:00

If you are pressing the back button in your Windows Phone 7 app with an opened popup, the NavigationService will leave the current page and navigate back to the previous page on the navigation stack.

To close the popup instead of navigating, you can use this: Handling the “Back” Button with a Popup Open on Windows Phone 7 | Toetapz's Blog

Windows Phone 7: Using threading for heavy operations

2010-11-14T10:56:00.001+01:00

For developers of Windows Phone 7 apps it is important to know all existing concepts of scheduling tasks on Windows Phone 7. At Windows Phone 7 the core threads are the Compositor Thread which interacts with the GPU and the UI Thread. The UI Thread is the main thread, where all your code will normally be executed. But the UI Thread have to handle some important events of the OS and is responsible for the layout management. Therefore it is not a good idea to do heavy actions in the UI thread, because then your app will loose very quickly the “smooth” experience of Windows Phone 7.

The normal way is to create for this heavy operations (parsing JSON, rendering bitmaps, etc.) a new thread directly or using the BackgroundWorker class. An alternative way you can found at

Scheduling tasks on Windows Phone 7 | .NET Zone.

Instead of using the direct ways for new thread creation, you could use the built-in scheduling mechanism which are in the namespace Microsoft.Phone.Reactive. The Scheduler class in this namespace allows you to defer execution of pretty much everything you need. You can either directly operate with Scheduler or via IScheduler, that will get a thread instance from Scheduler.

Using authenticated RIA Services with Windows Phone 7

2010-11-13T11:17:00.001+01:00

In my older post RIA Services: Windows Phone 7 and SOAP endpoint | .NET - Red zone : Best practices and latest stuff I have described how a RIA Service can be used as normal WCF SOAP service for example with Windows Phone 7.

But if you want to use RIA Services with Windows Phone 7, there is the problem that Silverlight for Windows Phone 7 does not support authentication headers. But using the instructions here Using Authenticated Ria Services on your WP7 phone - Marcel de Vries, MVP Team System - blog community you can still use the cool authorization mechanism of WCF RIA Services with Windows Phone 7.

The key steps are:

1. Add enableHttpCookieContainer="true" to your ServiceReferences.ClientConfig

After the proxy is generated enable the HttpCookieContainer at your bindings for authentication service and your domain service. You have to remove it for each proxy new configuration to avoid an error message during proxy generation.

   1: <bindings>

   2:             <basicHttpBinding>

   3:                 <binding name="BasicHttpBinding_AuthenticationServiceSoap" maxBufferSize="2147483647"

   4:                          enableHttpCookieContainer="true"

   5:                     maxReceivedMessageSize="2147483647">

   6:                     <security mode="None" />

   7:                 </binding>

   8:                 <binding name="BasicHttpBinding_EmployeeDomainServiceSoap" maxBufferSize="2147483647"

   9:                       enableHttpCookieContainer="true"

  10:                     maxReceivedMessageSize="2147483647">

  11:                     <security mode="None" />

  12:                 </binding>

  13:             </basicHttpBinding>

  14:         </bindings>

2. Store the returned cookie container of your Login-Call for the next service calls

   1: protected virtual void OnLoginCompleted(object sender, LoginCompletedEventArgs e)

   2:        {

   3:            var args = new LoginServiceCompletedEventArgs();

4:

   5:            CookieContainer = null;

6:

   7:            if (e.Result != null)

   8:            {

   9:                args.User = null;

  10:                args.Error = true;

11:

  12:                CookieContainer = _authclient.CookieContainer;

  13:                ViewModelLocator.AuthCookieContainer = _authclient.CookieContainer;

Hint: Don’t be surprised that the cookie container looks empty at this point (count is 0). There is a kind of “magic” cookie still in there.

3. Use the returned cookie container for your proteced domain service calls

   1: var client = new EmployeeDomainServiceSoapClient

   2:                  {

   3:                      CookieContainer = ViewModelLocator.AuthCookieContainer

   4:                  };

Windows Phone 7: My Interview on Mobile360 and .NET Magazin

2010-11-11T21:16:00.001+01:00

My interview (in german only) about developing Windows Phone 7 apps could be read at the Mobile360 – Website: Was Entwickler bei Windows Phone 7 beachten sollten or at .NET Magazin Was Entwickler ・er Windows Phone 7 wissen sollten.

New Silverlight Toolkit for Windows Phone 7 available

2010-11-06T10:42:00.001+01:00

The new November 2010 edition of the open source-based Silverlight Toolkit for Windows Mobile developers brings new pre-built controls that they can make your apps easily and refine. The new and exciting elements AutoCompleteBox, ListPicker LongListSelector (this control helps a lot), different page transition effects (page transitions) are now available in the current version. Of course the controls known from the previous version remain included in the scope of the Toolkit (GestureService GestureListener, ContextMenu, DatePicker, TimePicker, ToggleSwitch, WrapPanel).

You can download the toolkit here: Silverlight - Release: Silverlight for Windows Phone Toolkit - Nov 2010

WindowsPhone 7: NavigationService.Back raises Exception

2010-10-28T13:48:00.001+02:00

Sometime a NavigationService.Back call could raise an exception, if the user tombstoned your Windows phone 7 app and you try to call a Navigations.Back after this.

Possible szenario: You ask the user “Do you really want to delete this item?”. After returning a OK from your MessageBox you delete the item and in all cases you want to return from your detail page to your list page with NavigationService.Back. To avoid a exception you have to put your NavigationService.Back call in a try..catch statement, because the user could press the windows button at your Messagebox and after this the CLR will raises a Cancel for your messagebox and executes the rest of your code with the NavigationService.Back call. Guess from me: Because this situation is not handled by the Silverlight for Windows Phone framework a exception will occur.

Windows Phone 7: Tombstoning and Messagebox

2010-10-28T13:28:00.001+02:00

For a good usabilty for your Windows Phone 7 app you should consider to save your Messagebox text as transient data for example with help of the PhoneApplicationService.Current.State Dictionary. Why is this necessary? For example if the user gets a call or wants to switch to a other ap by pressing the windows button and have not read the Messagbox the user should shown it again after he return to your app.

We use in our project the following class which do all the work for us.

The Show-methods wrapps the orginal MessageBox-Show methods (one override is missing, because a show method with return value for questions make no sense. After tombstoning you loose your functional context, so this Messagebox type should be handled). The ShowFromTransientValues-Method is the key for the suggested behaviour and can be called after you bring your application in a proper state – for example in the first PageLayoutUpdated-Event after reactivation.

HINT: The MessageBox.Show method will return in case of tombstoning always a cancel value. That is a fact that you should keep in mind for Windows Phone 7 programming.

   1: public static class TransientMessageBox

   2:     {

   3:         const string MessageTextKey = "TransientMessageBoxText";

   4:         const string MessageCaptionKey = "TransientMessageBoxCaption";

5:

   6:         public static void ShowVirtual(string messageBoxText)

   7:         {

   8:             TransientStorageHelper.AddOrUpdate(MessageTextKey, messageBoxText);

   9:         }

10:

  11:         public static void ShowVirtual(string messageBoxText, string caption)

  12:         {

  13:             TransientStorageHelper.AddOrUpdate(MessageTextKey, messageBoxText);

  14:             TransientStorageHelper.AddOrUpdate(MessageCaptionKey, caption);

  15:         }

16:

  17:         public static void Show(string messageBoxText)

  18:         {

  19:             ShowVirtual(messageBoxText);

20:

  21:             var result = MessageBox.Show(messageBoxText);

22:

  23:             Debug.WriteLine("Transient MessageBox result:" + result);

24:

  25:             if (result == MessageBoxResult.OK)

  26:             {

  27:                 RemoveTextKey();

  28:             }

  29:         }

30:

  31:         public static void Show(string messageBoxText, string caption)

  32:         {

  33:             ShowVirtual(messageBoxText, caption);

34:

  35:             var result = MessageBox.Show(messageBoxText, caption, MessageBoxButton.OK);

36:

  37:             Debug.WriteLine("Transient MessageBox result:" + result);

38:

  39:             if (result == MessageBoxResult.OK)

  40:             {

  41:                 RemoveAllKeys();

  42:             }

  43:         }

44:

  45:         private static void RemoveAllKeys()

  46:         {

  47:             TransientStorageHelper.Remove(MessageTextKey);

  48:             TransientStorageHelper.Remove(MessageCaptionKey);

  49:         }

50:

  51:         private static void RemoveTextKey()

  52:         {

  53:             TransientStorageHelper.Remove(MessageTextKey);

  54:         }

55:

  56:         public static void ShowFromTransientValues()

  57:         {

  58:             if (!PhoneApplicationService.Current.State.ContainsKey(MessageTextKey)) return;

59:

  60:             if (PhoneApplicationService.Current.State.ContainsKey(MessageCaptionKey))

  61:             {

  62:                 if (MessageBox.Show(TransientStorageHelper.GetValue<string>(MessageTextKey),

  63:                                 TransientStorageHelper.GetValue<string>(MessageCaptionKey),

  64:                                 MessageBoxButton.OK) == MessageBoxResult.OK)

  65:                 {

  66:                     RemoveAllKeys();

  67:                 }

  68:             }

  69:             else

  70:             {

  71:                 if (MessageBox.Show(TransientStorageHelper.GetValue<string>(MessageTextKey)) == MessageBoxResult.OK)

  72:                 {

  73:                     RemoveTextKey();

  74:                 }

  75:             }

  76:         }

  77:     }

Unittest: Testing non-public methods

2010-10-18T21:35:00.001+02:00

Sometimes you want to write unit tests against methods that aren't publicly exposed. Rather than make these private methods public, which is a bad idea, you can specify friendly assemblies to which your methods will be exposed.

All you have to do is edit the AssemblyInfo.cs of the assembly you want to expose to your tests and add the following line ("SampleTestProject" is the name of the test assembly):

[assembly: InternalsVisibleTo("SampleTestProject")]

After this change in the assembly.cs and a rebuild, your “internal” signed methods will be exposed.