Creating custom build configurations for the .NET Core project format

April 24, 2017WindowsMSBuild, Build Configurations, .NET, .NET CoreCommentsEdit

MSBuild based projects have two default build configurations: Debug and Release.

While these two configurations are enough for most projects, some might actually require custom build configurations that will support different environments, alternative build targets, etc..

Until now we could use Visual Studio Configuration Manager to easily create a copy an existing configuration setup, and then change small bits to match our specifications.

But now there’s a new csproj format for .NET Core, and while it includes the expected Debug and Release build configurations, the “copy configuration” process doesn’t work anymore!

The problem is that the new project format is based in quite a few implicit defaults, so Visual Studio Configuration Manager can’t actually create a copy of the existing build configurations with all the properties set.

Introducing the MSBuild Configuration Defaults

As I couldn’t find a way to “inherit” from the base Debug and Release build configurations, I tried to understand what properties were actually required on each of them, and then create some build scripts that would set them for me!

Those MSBuild scripts are available here and can easily be installed by running Install-Package MSBuildConfigurationDefaults on the Package Manager Console, or added with the Visual Studio NuGet Packages Manager.

After adding the NuGet package, I recommend closing and re-opening the solution to ensure that the build scripts are correctly loaded.

Usage

Once installed, any custom build configuration name starting or ending on “Debug” will have the following build properties set by default:

<DefineConstants>$(DefineConstants);DEBUG;TRACE</DefineConstants>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>

Similarly, any custom build configuration name starting or ending on “Release” will have the following build properties set by default:

<DefineConstants>$(DefineConstants);RELEASE;TRACE</DefineConstants>
<DebugSymbols>false</DebugSymbols>
<DebugType>portable</DebugType>
<Optimize>true</Optimize>

If any of these properties are set on the project, those values will have override the defaults above.

If you don’t want to name your custom build definition according to the rules above, just add a ConfigurationGroup property and set the value to Debug or Release to ensure those build definitions get the appropriate default properties set.

The following is an example of a custom build configuration called “Production”, that has the ConfigurationGroup set to “Release” (so it gets the default property values set as for the a “Release” build configuration), but also overrides the DebugSymbols property default value:

<PropertyGroup Condition="'$(Configuration)' == 'Production'">
  <ConfigurationGroup>Release</ConfigurationGroup>
  <DebugSymbols>true</DebugSymbols>
</PropertyGroup>

Await your event handlers completion with Deferred Events

April 4, 2017WindowsAsync, Events, Deferred Events, .NET, .NET StandardCommentsEdit

Deprecation notice: The DeferredEvents are now part of the Microsoft.Toolkit where it will be maintained from this point on.

Developers should avoid async void methods, but there are some situations where this is a “necessary evil”, and event handlers are one of those cases.

If one needs to use the await keyword inside an event handler code, the method itself must be async void

The following is an example of this:

public sealed partial class MainPage : Page
{
    public MainPage()
    {
        InitializeComponent();


        Loaded += MainPage_Loaded;
    }


    private async void MainPage_Loaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
    {
        await DoSomethingAsync();


        await DoSomethingMoreAsync();
    }
}

On the above example, the MainPage_Loaded is an async void method that will as it needs to await for the completion of some of its calls, but sometimes we also need to allow the event invoker to wait for all handlers to complete.

Inspired on how the background tasks use a deferral approach to solving this problem (as they too are void methods), I came up with a similar approach!

Introducing the Deferred Events

A “deferred event” is basically an event that allows the invoker to wait for the completion of all event handlers.

My personal implementation is available on the DeferredEvents NuGet package that you can install by running Install-Package DeferredEvents on the Package Manager Console, or add with Visual Studio NuGet Packages Manager.

This is a .NET Standard 1.0 package, so you should be able to use it on any .NET project!

If you want to take a look at what’s inside, the full source code is available here.

Usage

Here is an example of a deferred event:

public event EventHandler<DeferredEventArgs> MyEvent;

The only difference here to a regular event is that the event arguments have to be of type DeferredEventArgs (or a custom class inheriting from them), and that’s what allows the whole thing to work!

Now take a look at how we raise this event:

await MyEvent.InvokeAsync(sender, new DeferredEventArgs());

The InvokeAsync() is an extension method that will wait for all event handlers to finish their work before we proceed.

And finally, here’s how our event handler looks like:

public async void OnMyEvent(object sender, DeferredEventArgs e)
{
    var deferral = e.GetDeferral();


    await DoSomethingAsync();


    deferral.Complete();
}

The trick here is to call e.GetDeferral() to retrieve a deferral object, and just before we exit the method, we do deferral.Complete() to notify the invoker that we have completed our work!

There are a few rules that you have to be aware of:

You only need to call e.GetDeferral() if you actually want to the event caller to wait for the completion of the event handler; if you don’t call it, it will just behave as a regular event handler.
You must call e.GetDeferral() to get an EventDeferral instance before any await call in your code to ensure that the event caller knows that it should wait for deferral.Complete(); ideally, it should be the first thing you do in the event handler code.
If you have indeed called e.GetDeferral(), then you must call deferral.Complete() to signal that the event handler has finished.

To ensure the correct usage of the deferred events, use the following as a template for your event handlers:

public async void OnMyEvent(object sender, DeferredEventArgs e)
{
    var deferral = e.GetDeferral();


    try
    {
        // awaiteable code
    }
    finally
    {
        deferral.Complete();
    }
}

Alternatively, you can also use the using pattern like this:

public async void OnMyEvent(object sender, DeferredEventArgs e)
{
    using (e.GetDeferral())
    {
        // awaiteable code
    }
}

Setting a custom User-Agent in the UWP WebView control

March 21, 2017WindowsUser-Agent, WebView, HttpClient, UrlMkSetSessionOption, UWP, Windows, Windows 10, WPDevCommentsEdit

I recently came into a UWP project requiring all HTTP requests to use a specific User-Agent string.

That’s quite easy to do if you only use Windows.Web.Http.HttpClient as there’s a managed property for that purpose: HttpClient.DefaultRequestHeaders.UserAgent.

Similarly, the same applies for System.Net.Http.HttpClient and the HttpClient.DefaultHeader.UserAgent property.

The real problem is if you need to use the WebView control to present web content, as there’s no managed property to change the user-agent!

It is possible to create a HttpRequestMessage instance, set a custom user-agent string in it, and then call the WebView.NavigateWithHttpRequestMessage method, but that will only work for that specific navigation request.

Any requests invoked from inside the webview (like a form post) will use the system default user-agent string.

So what’s the solution?

The solution comes in the form of a Win32 API called UrlMkSetSessionOption.

Amongst other things, this API allows you to set the default user-agent string for the current internet session!

Here’s an example of how to use it; first, add the following class to your app:

public class UserAgentHelper
{
    [DllImport("urlmon.dll", CharSet = CharSet.Ansi, ExactSpelling = true)]
    private static extern int UrlMkSetSessionOption(int dwOption, string pBuffer, int dwBufferLength, int dwReserved);


    private const int URLMON_OPTION_USERAGENT = 0x10000001;


    public static void SetDefaultUserAgent(string userAgent)
    {
        UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, userAgent, userAgent.Length, 0);
    }
}

Now load your App.xaml.cs file and ensure you call the UserAgentHelper.SetDefaultUserAgent() method inside the App class constructor:

public App()
{
    // remaining code


    UserAgentHelper.SetDefaultUserAgent("MyApp/1.0");
}

From that point on, any webview inside your app will use the specified user-agent string (“MyApp/1.0” in our example above)!

One final note: only a few Win32 API’s are actually allowed in apps published to the Windows Store (you can check the complete list here)!

The Windows Store recently allowed for apps to use the UrlMkSetSessionOption API, but if you look at the list above you will notice that it’s not yet listed; that should change once Microsoft updates the list on that page.

Kudos to Hermit Dave for pointing me in the right direction for a solution for this problem!

Migrated from WordPress to Jekyll

March 13, 2017UncategorizedWordPress, Jekyll, GoDaddy, Github PagesCommentsEdit

For a long time now, my blog has been powered by WordPress and hosted on GoDaddy shared hosting.

Last week I noticed that the blog was down, and when I opened GoDaddy’s shared hosting administration area, I got a database connection error message.

I then did what anyone in this situation would do: get help!

However, contacting GoDaddy support proved completely useless, as all I got was something along the lines of “yes, there’s a problem and we’re working on to fix it; no, we don’t know when it’s gonna be fixed, so please try later”…

Just had a chat with @GoDaddy support, their server is down and all I got was "we know it's down, just try later..." #fail @GoDaddyHelp
— Pedro Lamas (@pedrolamas) March 7, 2017

After some 5 hours, the blog was back up and running… but there was a big problem: some content had disappeared!

I’m guessing they had some problem with the database server, and their “fix” involved recovering the databases from an old backup.

Seems @GoDaddy hosting admins "fix" was to RECOVER AN OLD DATABASE BACKUP, so all my latest changes have been lost... @GoDaddyHelp https://t.co/ROROWqxfQP
— Pedro Lamas (@pedrolamas) March 10, 2017

That was the final reason I needed to completely ditch WordPress and GoDaddy, and migrate to something faster and more recent: this blog is now fully powered by Jekyll and hosted in GitHub Pages!

Major advantages of this approach are:

No more MySQL or any other database server involved
full control over rendered content
everything is statically generated on every commit of the git repo, so it’s blazing fast!
I can host it for free in GitHub Pages and add some nice features like allowing other people to send me Pull Requests with fixes and improvements (or just to correct my recurrent typos!)

This right now is actually the first post I write in the new platform! :)

There are still a few quirks to fix, so if you find any problem please report it by creating a new issue and I’ll take care of it as soon as possible!

Awarded Microsoft Windows Development MVP 2017

March 2, 2017UncategorizedMicrosoft, MVP, UWP, Windows, WPDevCommentsEdit

It is with great pride that I received the Microsoft Most Valuable Professional (MVP) Award 2017 for Windows Development!

From the Microsoft MVP award overview page:

“…the Microsoft MVP Award is our way of saying “Thanks!” to outstanding community leaders.”

This is my first MVP Awards and to me feels like the top recognition for all the work I’ve been doing for the past few years with the community around Microsoft Technologies, particularly in Windows and Windows Phone development.

I consider this award as a personal achievement, but it is one that I could not have accomplished without the help and support of some people, specifically:

Scott Lovegrove, Joost van Schaik, Glenn Versweyveld, Hermit Dave, Sébastien Lachance, Bart Lannoeye, and quite a few other distinguished MVP’s!
Alberto Silva, Sandro Pereira, Tiago Pascoal, Paulo Morgado, and other fellow Portuguese MVP’s!
Luis Calado, João Pedro Martins, Clint Rutkas, and quite a few other Microsoft employees!
my wife, Joana, who has the patience to put up with me doing “geeky” stuff all the time!

…and finally but most importantly, the whole community, who reads my blog, follows me on twitter, checks my code contributions, downloads my apps, and gives me the opportunity to carry on doing what I’ve done so far and that will continue to improve in the future!

Thanks! :)

Adaptive Triggers failing? Better check your control names!

December 9, 2016WindowsAdaptive, AdaptiveTrigger, UWP, Windows, Windows 10, WPDevCommentsEdit

TL;DR

Adaptive triggers will not work if you are trying to change a control whose instance name is the same as one of the VisualStates of any control on the page, so make sure you name your controls accordingly!

The long run…

I recently came to discover what I believe to be a UWP platform bug related to how one names the instance controls and how these may collided with the VisualState names!

Let’s take the following sample code for a simple AdaptiveTrigger usage example:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <Button x:Name="MyButton" Content="I don't do anything!" />


    <VisualStateManager.VisualStateGroups>
        <VisualStateGroup x:Name="VisualStateGroup">
            <VisualState x:Name="VisualStateNarrow">
                <VisualState.StateTriggers>
                    <AdaptiveTrigger MinWindowWidth="0" />
                </VisualState.StateTriggers>
                <VisualState.Setters>
                    <Setter Target="MyButton.Background" Value="Red" />
                </VisualState.Setters>
            </VisualState>


            <VisualState x:Name="VisualStateNormal">
                <VisualState.StateTriggers>
                    <AdaptiveTrigger MinWindowWidth="600" />
                </VisualState.StateTriggers>
                <VisualState.Setters>
                    <Setter Target="MyButton.Background" Value="Green" />
                </VisualState.Setters>
            </VisualState>
        </VisualStateGroup>
    </VisualStateManager.VisualStateGroups>
</Grid>

Here we can see we have a Button called “MyButton”, who’s background color will change accordingly to the window size: if the window width is above 600, the button will be green, and if it is below 600, it will be red.

Now here’s how it looks when we run the sample code:

Simple AdaptiveTrigger working

Works exactly as expected! :)

If you take a look at the Button styles and templates, you will find out that the Button control contains the following named VisualStates: “Normal”, “PointerOver”, “Pressed”, “Disabled”.

Given this information, let’s rename our button from “MyButton” to “Pressed”:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <Button x:Name="Pressed" Content="I don't do anything!" />


    <VisualStateManager.VisualStateGroups>
        <VisualStateGroup x:Name="VisualStateGroup">
            <VisualState x:Name="VisualStateNarrow">
                <VisualState.StateTriggers>
                    <AdaptiveTrigger MinWindowWidth="0" />
                </VisualState.StateTriggers>
                <VisualState.Setters>
                    <Setter Target="Pressed.Background" Value="Red" />
                </VisualState.Setters>
            </VisualState>


            <VisualState x:Name="VisualStateNormal">
                <VisualState.StateTriggers>
                    <AdaptiveTrigger MinWindowWidth="600" />
                </VisualState.StateTriggers>
                <VisualState.Setters>
                    <Setter Target="Pressed.Background" Value="Green" />
                </VisualState.Setters>
            </VisualState>
        </VisualStateGroup>
    </VisualStateManager.VisualStateGroups>
</Grid>

This is the result if you run the code again:

AdaptiveTrigger now failing

What you see here is that the initial state was in fact applied, but it failed to change once we started to change the window size as it was supposed to!

Further testing made me aware that this is not only influenced by the visual states of the control we are manipulating, but by all controls on the page!

As an example of this, on the following code we have now added a ComboBox control, which will also fail the adaptive changes as I named our button Focused which matches one of the ComboBox visual states:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <Button x:Name="Focused" Content="I don't do anything!" />
    <ComboBox />


    <VisualStateManager.VisualStateGroups>
        <VisualStateGroup x:Name="VisualStateGroup">
            <VisualState x:Name="VisualStateNarrow">
                <VisualState.StateTriggers>
                    <AdaptiveTrigger MinWindowWidth="0" />
                </VisualState.StateTriggers>
                <VisualState.Setters>
                    <Setter Target="Focused.Background" Value="Red" />
                </VisualState.Setters>
            </VisualState>


            <VisualState x:Name="VisualStateNormal">
                <VisualState.StateTriggers>
                    <AdaptiveTrigger MinWindowWidth="600" />
                </VisualState.StateTriggers>
                <VisualState.Setters>
                    <Setter Target="Focused.Background" Value="Green" />
                </VisualState.Setters>
            </VisualState>
        </VisualStateGroup>
    </VisualStateManager.VisualStateGroups>
</Grid>

I’ve reported this issue to Microsoft, so for now all we can do is to be aware of it and make sure we name our controls so not to use the same names as any of their visual states!

Cimbalino Toolkit 2.4.0

December 6, 2016Windows, Windows PhoneCimbalino, UWP, Windows, Windows 10, Windows Phone, WPDevCommentsEdit

I know the blog as been quite a bit quiet for the last couple of months, but I just wanted to let you know that Cimbalino Toolkit version 2.4.0 is now available!

As I didn’t put a blog post for the previous version, here’s the complete change log for everything since 2.2.0 till the current 2.4.0:

Now targeting SDK 14393 (Windows 10 Anniversary edition)
New MasterDetailView control (UWP only)
New ExtendedPageBase class, IHandleNavigatingFrom, IHandleNavigatedFrom and IHandleNavigatedTo interfaces (allows handling of Page.OnNavigatingFrom(), Page.OnNavigatedFrom() and Page.OnNavigatedTo() methods from inside view models)
New BooleanToObjectConverter, CollectionCountToObjectConverter, ComparableToObjectConverter, EmptyCollectionToObjectConverter, and EmptyStringToObjectConverter
Added CancellationToken support to IMessageBoxService and ILocationService
HamburgerMenuButton will now allow parameter check for button highlighting
Improvements over the INavigationService interface and implementation
Other fixes and improvements

Changing the Raspberry Pi Touch Display Rotation in Windows 10 IoT

April 29, 2016WindowsIoT, Raspberry Pi, RPi, Windows 10CommentsEdit

If you have a Raspberry Pi 3 running Windows 10 Core IoT and the 7” touch display, then this post is for you!

Assuming you already installed the Windows 10 IoT in your Pi 3 and that it is currently up and connected to the network, you can open the Windows 10 IoT Core Dashboard, go to the “My Devices” tab and find your device listed there.

If you now click the “Open in Device Portal” option, the browser will launch, ask you to login with your credentials, and then show you the “Home” page of the Device Portal.

On the bottom you will find the “Display Orientation” option:

Display Orientation setting in the Device Portal

Given my touch screen is placed upside down, I changed this setting to “Landscape (Flipped)”, and after rebooting the device I noticed that it flipped the touch screen display as requested, but it didn’t also flip the touch targets (so you’ll need to mentally rotate every point you touch on the screen to make it do what it is supposed to do)!

Under the hood, what this setting is doing is adding display_rotation=2 to the Raspberry Pi “config.txt” file, but that’s not the proper way of doing this for the touch screen!

After reading the Raspberry Pi Display troubleshooting, I realized that one should use lcd_rotate=2 instead, which will rotate the lcd display and touch targets!

So the fix is quite easy: just open the \\<your-pi-ip-address>\c$ network share, go to the “EFIESP” folder and inside of it, find and edit the “config.txt” file!

Remove any display_rodate entry and add lcd_rotate=2 to the end of the file, save, reboot the Pi, and that should fix the problem completely! :)