Paulo Morgado

Feedback Requested: Usability Of The Remarks Section In Reference Topics

Microsoft is planning to expand the Remarks section of selected types in the .NET Framework Class Library to provide detailed usage information and code examples. (For an example, see the Remarks section for the System.String class.) In the current design, the Remarks section isn’t easily discoverable, because member tables take up a lot of screen real estate.

Some alternate page designs are proposed to address this problem.

Click here to provide your feedback.

Windows 8 SDK Customer Satisfaction Survey

Windows 8 introduces a number of innovations in the way information is delivered to developers. Microsoft would like to know how well these are working for you, and where they can make further changes to improve your experience.

To review the site before you complete the survey, visit the Windows 8 Dev Center. In particular, have a look at the section called Learn to build Metro style apps.

A few questions in the survey are about about how the Windows 8 site experience compares to the iOS and Android sites. If you aren’t an experienced iOS or Android developer, feel free to skip these parts. But, if you’ve made apps for those platforms, or if you’d like to compare site features based on just a browse through those sites, Microsoft would like to hear your opinion.

The survey will be available here until July 27, 2012.

Breaking Changes In Argument List Evaluation In C# 5.0

The C# Language Specification states on §7.5.1.2 that “(…) the expressions or variable references of an argument list are evaluated in order, from left to right (…)”.

So, when this code is compiled with the C# 4.0 compiler:

static void M(
    int x = 10,
    int y = 20,
    int z = 30)
{
    Console.WriteLine(
        "x={0}, y={1}, z={2}", x, y, z);
}

static void Main(string[] args)
{
    int a = 0;

    M(++a, z: ++a);
}

and run, this unexpected output is obtained:

x=2, y=20, z=1

In fact, fixing this compiler flaw was the cause of one of the few breaking changes introduced in C# 5.0.

Using the 5.0 compiler, the expected result is obtained:

x=1, y=20, z=2

To avoid this type of surprises, expression evaluation should be avoided in argument lists.

With this code:

int a = 0;

int i = ++a;
int j = ++a;

M(i, z: j);

the same result is obtained for both C# 4.0 and C# 5.0:

x=1, y=20, z=2

How To: Make XAML Content Globalizable When Using Value Converters

(This content was written based on Silverlight for Windows Phone, but might be valid for generic Silverlight.)

There are a many articles on MSDN (and all over the Internet) about globalization and localization of Silverlight applications in general and specifically Windows Phone 7 applications but I haven’t found any that uses a value converter.

If you read the documentation for the IValueConverter interface, you can see that both in the Convert and ConvertBack methods have a culture parameter of type CultureInfo.

And why would we need the culture for the conversion? Imagine the application is a shop that shows prices in more than one currency. Or the application is a currency converter.

The culture parameter is used as the culture of the conversion. Any place inside the Convert or ConvertBack methods where a CultureInfo or IFormatProvider instance is need, the culture parameter should be used:

public class MoneyValueConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value != null)
        {
            return string.Format(culture, "{0:C}", value);
        }

        return null;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

The value of the culture parameter is determined in the following order:

1. The converter looks for the ConverterCulture property on the Binding object.
2. If the ConverterCulture value is null, the value of the Language property is used.

The first case is very straightforward:

<TextBlock Text="{Binding Euros, Converter={StaticResource MoneyValueConverter}, ConverterCulture=pt-PT}" />
<TextBlock Text="{Binding Dollars, Converter={StaticResource MoneyValueConverter}, ConverterCulture=en-US}" />

But that should only be used when the culture of the conversion differs form the application culture or has an explicit value. The second case is the most frequently used and that’s where things get complicated. The value of the Language property of an element, if not explicitly set, is inherited from its container. In the case of Windows Phone 7, up to the phone application frame. And it’s never null.

I was expecting that the value of the Language property of the phone application frame would reflect the value of the current culture but, as far as I can tell, it’s always en-US.

So, if, unless explicitly set, the language is always en-US. How to specify which culture to use inside the value converter methods? The current culture could be used, but how to know if the language has been changed or the culture has been explicitly specified?

The solution is setting the language on the phone application frame and always to be able to use the culture parameter inside the converter methods:

this.RootFrame = new PhoneApplicationFrame
{
    Language = XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.Name)
};

The correct way to get the XML language would be to use the IetfLanguageTag property of the current culture, but that property is not available on Silverlight.

As far as I could find, you won’t get into trouble unless you’re dealing with Chinese cultures. But if you’re like me, you’ll probably be publishing your applications worldwide.

It’s not an hard problem to solve, though. A couple of extension method can solve it:

public static class CultureInfoExtensions
{
    public static XmlLanguage GetXmlLanguage(this CultureInfo culture)
    {
        return XmlLanguage.GetLanguage(culture.GetIetfLanguageTag());
    }

    public static string GetIetfLanguageTag(this CultureInfo culture)
    {
        switch (culture.Name)
        {
            case "zh-CHT":
                return "zh-Hant";
            case "zh-CHS":
                return "zh-Hans";
            default:
                return culture.Name;
        }
    }
}

And now the language of the root phone application frame can be properly initialized:

// Avoid double-initialization
// Do not add any additional code to this method
private void InitializePhoneApplication()
{
    Debug.WriteLine("{0} >> InitializePhoneApplication", DateTime.Now.Ticks);

    if (this.phoneApplicationInitialized)
    {
        return;
    }

    // Create the frame but don't set it as RootVisual yet; this allows the splash
    // screen to remain active until the application is ready to render.
    this.RootFrame = new RadPhoneApplicationFrame
        {
            Language = CultureInfo.CurrentUICulture.GetXmlLanguage()
        };

    this.RootFrame.Navigated += CompleteInitializePhoneApplication;

    // Handle navigation failures
    this.RootFrame.NavigationFailed += RootFrame_NavigationFailed;

    // Ensure we don't initialize again
    this.phoneApplicationInitialized = true;
}

• Creating Globally Aware Applications
• Localizing Silverlight-based Applications
• How to: Make XAML Content Localizable
• Globalization and Localization Overview for Windows Phone
• Globalization and Localization for Windows Phone
• How to: Build a Globalized Application for Windows Phone
• How to: Build a Localized Application for Windows Phone
• Code Samples for Windows Phone : Globalization Sample

Testing for Continuous Delivery with Visual Studio 2012 RC

Microsoft Patterns & Practices has released a book with guidance on Testing for Continuous Delivery with Visual Studio 2012 RC.

The book and its content can be found both in the MSDN site and the CodePlex site.

I’m deeply honored to have been part of the review panels.

People+ For Windows Phone

Recently, I’ve released a Windows Phone application to explore and use contact information.

In this application I used components and/or guidance from:

• Cimbalino Windows Phone Toolkit
• Metro Studio
• Microsoft^® Expression^® Blend^®
• Microsoft^® Expression^® Design
• Microsoft^® Visual Studio^®
• MVVM Light
• paint.net
• Reactive Extensions (Rx)
• TechSmith^® SnagIt^®
• Telerik
• Templarian

In future posts, I’ll be showing some tips, tricks and components I’ve used in this application.

Explore and use your contacts’ information.

Search contacts by:

• name
• phone number
• e-mail address
• physical address
• websites
• company
• job title
• significant others
• children
• notes

* Trial limitations The trial version is fully functional but will show a purchase reminder and might show ads.

* Application limitations

The Windows Phone system imposes some limitations on application developers.

It is not possible to:

• access twitter information
• access linkedin information
• uniquely identify the contact
• change or provide access to change the contact information

* Privacy statement This application does not make any use of the contacts information other than displaying and searching it. When ads are displayed, however, device information might be sent to the ad provider (smaato Privacy Policy).

Hash Function Added To The PredicateEqualityComparer

Sometime ago I wrote a predicate equality comparer to be used with LINQ’s Distinct operator.

The Distinct operator uses an instance of an internal Set class to maintain the collection of distinct elements in the source collection which in turn checks the hash code of each element (by calling the GetHashCode method of the equality comparer) and only if there’s already an element with the same hash code in the collection calls the Equals method of the comparer to disambiguate.

At the time I provided only the possibility to specify the comparison predicate, but, in some cases, comparing a hash code instead of calling the provided comparer predicate can be a significant performance improvement, I’ve added the possibility to had a hash function to the predicate equality comparer.

You can get the updated code from the PauloMorgado.Linq project on CodePlex,

WCF HTTP User Agent Message Adapter On GitHub And Nuget

Some time ago, I wrote about building an HTTP user agent message adapter for WCF.

Now, Henk J MeuleKamp (@hjmeulekamp) has published the code on GitHub (Wcf Useragent C# Library) and a usable library on Nuget (Message Inspector for WCF to add Useragent header by configuration).

My thanks to Henk.

Globalization, Localization And Why My Application Stopped Launching

When I was localizing a Windows Phone application I was developing, I set the argument on the constructor of the AssemblyCultureAttribute for the neutral culture (en-US in this particular case) for my application.

As it was late at night (or early in the dawn ) I went to sleep and, on the next day, the application wasn’t launching although it compiled just fine.

I’ll have to confess that it took me a couple of nights to figure out what I had done to my application.

Have you figured out what I did wrong?

The documentation for the AssemblyCultureAttribute states that:

The attribute is used by compilers to distinguish between a main assembly and a satellite assembly. A main assembly contains code and the neutral culture's resources. A satellite assembly contains only resources for a particular culture, as in [assembly:AssemblyCultureAttribute("de")]. Putting this attribute on an assembly and using something other than the empty string ("") for the culture name will make this assembly look like a satellite assembly, rather than a main assembly that contains executable code. Labeling a traditional code library with this attribute will break it, because no other code will be able to find the library's entry points at runtime.

So, what I did was marking the once main assembly as a satellite assembly for the en-US culture which made it impossible to find its entry point.

To set the the neutral culture for the assembly resources I should haveused (and eventually did) the NeutralResourcesLanguageAttribute. According to its documentation:

The NeutralResourcesLanguageAttribute attribute informs the ResourceManager of the application's default culture, and also informs the ResourceManager that the default culture's resources are found in the main application assembly. When looking up resources in the same culture as the default culture, the ResourceManager automatically uses the resources located in the main assembly instead of searching for a satellite assembly. This improves lookup performance for the first resource you load, and can reduce your working set.

Patterns & Practices Symposium Online - April 24, 2012

Microsoft patterns & practices symposiums are held regularly in the U.S. and abroad. Most of the speakers are from the Microsoft patterns & practices (p&p) team. The event is aimed primarily at software architects, developers, and technical managers. patterns & practices develops applied engineering guidelines to help software developers and architects build great solutions on the Microsoft platform.

Read more…