I’ve always found Portable Class Library (PCL) configuration to be a bit of a mystery. In simple cases, it’s simple: start a new PCL project in Visual Studio, select the environments you want to support, and away you go. But what’s going on under the hood, and what do all the options mean? How do I do this without Visual Studio?
Background: supporting Universal Windows Applications in Noda Time
Recently, I had a feature request for Noda Time to support Windows Phone 8.1 and Universal Windows Applications. This is something I haven’t done before, but it doesn’t sound too hard – it’s just a matter of changing an option in Visual Studio, surely… Unfortunately it’s not that simple for Noda Time. In order to support .NET 3.5 (and some other features which aren’t available in PCLs) the core NodaTime.dll project has multiple configurations which effectively split into “Desktop” and “PCL”. This has been achieved by hacking around with the .csproj file manually – nothing particularly clever, but the sort of thing which can’t be done directly in Visual Studio. This means that when I open the project properties in Visual Studio – even when I’m building a PCL version – it treats the project as a regular class library. (It confuses the heck out of ReSharper too in some cases, unfortunately.)
That’s not too hard to work around – I just need to know the name of the profile I want to support. A profile name is basically a single identifier which refers to the configuration of environments you want to support. Unfortunately, it’s pretty opaque – Noda Time 1.2 ships with “Profile2” which means “.NET 4.0, Windows 8 (store apps), Silverlight 4, Windows Phone 7. The simplest way to work out what profile I wanted was to create a new “regular” PCL in Visual Studio, unload the project, manually set the profile to Profile2 in the project file, reload the project, and then enable “Windows Phone 8.1”.
That then led to the next problem: Visual Studio 2013 (update 2) wanted to upgrade that sample project… because Profile2 is no longer really an option. You can’t manually set that combination in Visual Studio any more – it doesn’t display anything earlier than Silverlight 5 and Windows Phone 8. I now have two problems:
- Given that Visual Studio changes the project file for me with a warning when I open it, how can I check what I’ve actually built against? Does msbuild silently do the same thing?
- How can I find out what profiles are available, in order to select the most appropriate one?
Time to do some research…
Detecting a profile in a built assembly
First things first: if someone gives you a DLL, how can you detect what profile it was built against, and therefore which environments it can run in?
After hunting around in vain for a while, Petr K helped me out on Twitter: the crucial information is in the TargetFrameworkAttribute and its FrameworkName property, which is something like “.NETPortable,Version=v4.0,Profile=Profile2”. That can then be used with the FrameworkName class to parse out the profile name without writing any string manipulation code.
Then you just need to find the details of the profile…
Where are all the profiles?
Windows stores the profiles along with the reference assembles, in the .NETPortable framework directory – on my machine for example, that’s “C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETPortable”. There are then subdirectories v4.0, v4.5 and v4.6 – although it’s not 100% clear what those refer to. Within each of those, there’s a Profile directory, which contains a bunch of Profile[n] directories. Then under each Profile[n] directory, a SupportedFrameworks directory contains XML documents describing the supported frameworks for that profile. Phew! So as an example:
C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETPortablev4.0ProfileProfile2
contains the profile information for Profile2, including files:
- C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETPortablev4.0ProfileProfile2SupportedFrameworks.NET Framework 4.xml
- C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETPortablev4.0ProfileProfile2SupportedFrameworksSilverlight.xml
- C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETPortablev4.0ProfileProfile2SupportedFrameworksWindows 8.xml
- C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETPortablev4.0ProfileProfile2SupportedFrameworksWindows Phone Silverlight 7.xml
Each of those XML files consists of a single Framework element, with a variety of attributes. Not all elements have the same set of attributes, although everything has an Identifier, Family, Profile, MinimumVersion and DisplayName as far as I’ve seen. Here’s an example – the “Windows Phone Silverlight 7.xml” file listed above:
DisplayName=”Windows Phone Silverlight”
As noted by David Kean in comments, the “Identifier”, “Profile” and “MinimumVersion” are mapped to the corresponding properties in MSBuild; the combination of the three is unique for a target, but you need to be careful to look at all the relevant information… don’t just look at the Identifier attribute. Additionally, if there’s a MinimumVersionDisplayName, that’s probably the version you’ll be more familiar with – so in the example above, the displayed minimum version number is 7, which is what people think about for Windows Phone versions, even though the real minimum version number is 4.0 as far as the build is concerned.
Read David’s comment for more details – I don’t want to paraphrase it too much, in case I accidentally write something misleading.
What about the Xamarin frameworks?
As you can see above, Profile2 doesn’t include anything that looks like it’s a Xamarin framework. (Compare that with Profile136 for example, which includes Xamarin.iOS.xml and Xamarin.Android.xml.) But haven’t I previously said that Noda Time 1.2 works seamlessly in Xamarin.iOS and Xamarin.Android? Indeed I have. This is all very confusing, but as far as I’m aware, the Xamarin.* frameworks are only required if you want to build within Xamarin Studio and you’re not on a Windows machine. I could be wrong about that, but certainly there are some profiles which will work with some versions of Xamarin without a Xamarin-specific framework being on the list.
I would welcome more clarity on this, and if I learn any more about it (either in comments here or via other channels) I’ll update this post.
Where should the files go in NuGet packages?
The next issue to consider is that of NuGet packages. A NuGet package can contain multiple binaries for multiple target profiles – for example, the NodaTime NuGet package includes both the desktop and PCL versions. NuGet adds a reference to the right one when you install a package. How can it tell which binary is which? Through a directory structure. Here’s a piece of Noda Time’s nuspec package:
<file src=“binSigned ReleaseNodaTime.pdb” target=“libnet35-Client” />
<file src=“binSigned ReleaseNodaTime.xml” target=“libnet35-Client” />
<file src=“binSigned Release PortableNodaTime.dll” target=“libportable-win+net40+sl4+wp7” />
<file src=“binSigned Release PortableNodaTime.pdb” target=“libportable-win+net40+sl4+wp7” />
<file src=“binSigned Release PortableNodaTime.xml” target=“libportable-win+net40+sl4+wp7” />
<file src=“***.cs” target=“src” />
As you can see, the PCL files end up in libportable-win+net40+sl4+wp7. That works for Profile2, but it’s not the right directory for the profile I’ll end up using. So how do I work out what directory to use in the next version? I can look at the NuGet source code, or this handy table of profiles and corresponding NuGet targets. (Interestingly, that lists the directory for Profile2 as portable-net4+sl4+netcore45+wp7, so I’m not entirely sure what’s going on. I suspect the table is more reliable than whenever I got the name from when preparing a Noda Time release.)
This all sounds a bit fiddly. Shouldn’t there be a tool to make it simple?
Yes, yes there should. As it happens, Stephen Cleary has already written one, although I didn’t realise this until I’d also written one myself. Indeed, the table linked above is the output from Stephen’s tool.
My own tool is called PclPal, and the source is available on GitHub. Don’t expect polished code (or tests) – this was very much a quick and dirty hack to make life slightly easier. It could be the basis of a more polished tool – possibly even a “PCL profile explorer” or something similar. Oh, and it requires the Roslyn End User Preview.
Currently it’s just a command line tool with three options:
- “list” – lists the profiles on your system
- “dll ” – shows the details of the profile a particular assembly was built against
- “show ” – shows the details of a specify profile
Note that currently I’m not doing anything in terms of NuGet package directories, although that’s probably the next step, if I take this any further. (I may just use Stephen’s tool, of course…)
The world of PCLs is a bit of a mess, to say the least. It’s possible that there’s lots of really clear, up-to-date documentation explaining everything somewhere – but I have yet to find it. I suspect the main problem is that this is a moving target in all kinds of ways. Versioning is never easy, and between all the different variations possible here, I’m not entirely surprised it’s confusing.
Hopefully this post will help to shed a bit more light on things – please feel very free to leave corrections, as I definitely don’t want to propagate any falsehoods. I’ve definitely learned a thing or two in the last few days, and with tools such as PclPal and Stephen’s PortableLibraryProfiles, life should be that little bit easier…
3 thoughts on “Diagnosing Portable Class Libraries”
Great blog post! AFAIK, there is no good documentation on the subject. In particular, the Xamarin usage of PCLs remains a Great Mystery. :(
The NuGet directory that you use and the one from my table are actually the same. The latest version of my PortableLibraryProfiles just removed some of the special logic by using the actual identifier of the Windows Store platform. NuGet has several aliases, so “win” and “win8” actually resolve to the same framework as “netcore45” under the covers. The “netcore45” is what exists in the “Windows 8.xml” file (Identifier, MinimumVersion, and Profile define the FrameworkName for the included platform). So by deriving “netcore45” from the xml, I was able to remove the special logic for win/win8/win81/etc (and most other aliases).
Some aliases must remain; e.g., “wp7” is actually “sl4-windowsphone”, which cannot be specified as the NuGet directory because it contains a dash. All of those kinds of aliases are only for discontinued platforms; e.g., wp8 properly uses its own framework name. I have a blog post (http://blog.stephencleary.com/2012/05/framework-profiles-in-net.html) that goes into the gory details.
There is definitely a need for better tooling in this area. :)
A couple of comments:
1) “Identifier”, “Profile” and “MinimumVersion” all map to the appropriate properties in MSBuild. We use this so that we can block references to say Silverlight 5 projects when you aren’t targeting Silverlight 5 in the portable project. A combination of all three of these properties make a given target unique.
2) Family is used to group targets in the UI that might be unrelated in the traditional “framework” sense (ie represented by the “Identifier” in 1), but are related from a targeting perspective. For example, Windows Phone 7.5 and Windows Phone 8.
3) The reason this isn’t documented is because it’s exactly as you mentioned, a moving target. We know this is a mess (the profiles were a hack that was supposed to only last a single VS version), but we’re working at this very moment to simplify this entire thing.
@David: Thanks for the comment – I’ve edited the section about the different attributes.
I’m glad there’s work underway to simplify it – and I’m all too aware of how hard it is to come up with a grand unified scheme after the fact :)