Settings allow you to separate the parameters that configure the behavior of your app separate from the code, which allows you to change that behavior without rebuilding the app. This is handle at the app level for things like server addresses and API keys and at the user level for things like restoring the last user input and theme preferences. Xamarin.Forms provides direct support for neither, but that doesn’t mean you can’t easily add it yourself.
App Settings
Xamarin.Forms doesn’t have any concept of the .NET standard app.config. However, it’s easy enough to add the equivalent using embedded resources and the XML parser. For example, I built a Xamarin.Forms app for finding spots for coffee, food and drinks between where I am and where my friend is (MiddleMeeter, on GitHub). I’m using the Google APIs to do a bunch of geolocation-related stuff, so I need a Google API key, which I don’t want to publish on GitHub. The easy way to make that happen is to drop the API key into a separate file that’s loaded at run-time but to not check that file into GitHub by adding it to .gitignore. To make it easy to read, I added this file as an Embedded Resource in XML format:
Adding an XML file as an embedded resource makes it easy to read at run-time for app settings
I could’ve gone all the way and re-implemented the entire .NET configuration API, but that seemed like overkill, so I kept the file format simple:
<?xml version="1.0" encoding="utf-8" ?>
<config>
<google-api-key>YourGoogleApiKeyHere</google-api-key>
</config>
Loading the file at run-time uses the normal .NET resources API:
string GetGoogleApiKey() {
var type = this.GetType();
var resource = type.Namespace + "." +
Device.OnPlatform("iOS", "Droid", "WinPhone") + ".config.xml";
using (var stream = type.Assembly.GetManifestResourceStream(resource))
using (var reader = new StreamReader(stream)) {
var doc = XDocument.Parse(reader.ReadToEnd());
return doc.Element("config").Element("google-api-key").Value;
}
}
I used XML as the file format not because I’m in love with XML (although it does the job well enough for things like this), but because LINQ to XML is baked right into Xamarin. I could’ve used JSON, too, of course, but that requires an extra NuGet package. Also, I could’ve abstracting things a bit to make an easy API for more than one config entry, but I’ll leave that for enterprising readers.
User Settings
While app settings are read-only, user settings are read-write and each of the supported Xamarin platforms has their own place to store settings, e.g. .NET developers will likely have heard of Isolated Storage. Unfortunately, Xamarin provides no built-in support for abstracting away the platform specifics of user settings. Luckily, James Montemagno has. In his Settings Plugin NuGet package, he makes it super easy to read and write user settings. For example, in my app, I pull in the previously stored user settings when I’m creating the data model for the view on my app’s first page:
class SearchModel : INotifyPropertyChanged {
string yourLocation;
// reading values saved during the last session (or setting defaults)
string theirLocation = CrossSettings.Current.GetValueOrDefault("theirLocation", "");
SearchMode mode = CrossSettings.Current.GetValueOrDefault("mode", SearchMode.food);
...
}
The beauty of James’s API is that it’s concise (only one function to call to get a value or set a default if the value is missing) and type-safe, e.g. notice the use of a string and an enum here. He handles the specifics of reading from the correct underlying storage mechanism based on the platform, translating it into my native type system and I just get to write my code w/o worrying about it. Writing is just as easy:
async void button1_Clicked(object sender, EventArgs e) {
...
// writing settings values at an appropriate time
CrossSettings.Current.AddOrUpdateValue("theirLocation", model.TheirLocation);
CrossSettings.Current.AddOrUpdateValue("mode", model.Mode);
...
}
My one quibble is that I wish the functions were called Read/Write or Get/Set instead of GetValueOrDefault/AddOrUpdateValue, but James’s function names make it very clear what’s actually happening under the covers. Certainly the functionality makes it more than worth the extra characters.
User Settings UI
Of course, when it comes to building a UI for editing user settings at run-time, Xamarin.Forms has all kinds of wonderful facilities, including a TableView intent specifically for settings (TableIntent.Settings). However, when it comes to extending the platform-specific Settings app, you’re on your own. That’s not such a big deal, however, since only iOS actually supports extending the Settings app (using iOS Settings Bundles). Android doesn’t support it at all (they only let the user configure things like whether an app has permission to send notifications) and while Windows Phone 8 has an extensible Settings Hub for their apps, it’s a hack if you do it with your own apps (and unlikely to make it past the Windows Store police).
Where Are We?
So, while Xamarin.Forms doesn’t provide any built in support for app or user settings, the underlying platform provides enough to make implementing the former trivial and the Xamarin ecosystem provides nicely for the latter (thanks, James!).
Even more interesting is what Xamarin has enabled with this ecosystem. They’ve mixed their very impressive core .NET and C# compiler implementation (Mono) with a set of mobile libraries providing direct access to the native platforms (MonoTouch and MonoDroid), added a core implementation of UI abstraction (Xamarin.Forms) and integration into the .NET developer’s IDE of choice (Visual Studio) together with an extensible, discoverable set of libraries (NuGet) that make it easy for 3rd party developers to contribute. That’s a platform, my friends, and it’s separate from the one that Microsoft is building. What makes it impressive is that it takes the army of .NET developers and points them at the current hotness, i.e. building iOS and Android apps, in a way that Microsoft never could. Moreover, because they’ve managed to also support Windows Phone pretty seamlessly, they’ve managed to get Microsoft to back them.
We’ll see how successful Xamarin is over time, but they certainly have a very good story to tell .NET developers.
![ss1[5]](https://cdn.blot.im/folder/v-1db57359/blog_12688eba996c4a98b1ec3a945e78e4f1/public/post-images/13740-258.png "ss1[5]")
In 1992, I was a Unix programmer in Minneapolis. I’d graduated with a 
This is the last in a 4-part series on how to interview well. Parts 1-3 covered 
If you just found yourself here, you’ve stumbled onto a multi-part series on the technical interviewing process. Part 1 covered 
It’s incredibly important to interview well as you’re building your technical team. Further, interviewing well is hard to do and, like anything, you only get out of it what you put into it. In part 1 of this series, we discussed