feed.xml

<feed xmlns="http://www.w3.org/2005/Atom"><title type="text">Shannon's Blog</title><subtitle type="text">Shannon's Blog</subtitle><id>http://blog.shannonlewis.me/</id><updated>2016-09-03T10:59:23+10:00</updated><author><name>Shannon Lewis</name><uri>http://blog.shannonlewis.me</uri><email>slewis74@gmail.com</email></author><generator>Sandra.Snow Atom Generator</generator><link rel="alternate" href="http://blog.shannonlewis.me/feed.xml" /><link rel="self" type="text/html" title="Shannon's Blog" href="http://blog.shannonlewis.me/feed.xml" /><entry><id>http://blog.shannonlewis.me/2015/07/orienteer-origins/</id><title type="text">Orienteer's Origins</title><summary type="html">&lt;p&gt;I quick look back at my Orienteer journey.&lt;/p&gt;
</summary><published>2015-07-20T14:00:00Z</published><updated>2015-07-20T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2015/07/orienteer-origins/" /><content type="html">&lt;p&gt;In working through finally publishing Orienteer recently I spent some time looking back over the code, how it came to be and how it had evolved over the last few years.  It was an interesting journey, one I've really enjoyed and one I've learned a lot from.  Here are some of the highlights.&lt;/p&gt;

&lt;h2&gt;Phase 1 - Windows 8 and getting mobile&lt;/h2&gt;

&lt;p&gt;When Windows 8 beta arrived I picked up the SDKs and samples and started learning.  Having a WPF and C# background I went down the C#/XAML path, rather than WinJS.&lt;/p&gt;

&lt;p&gt;I dug around in a number of the samples and went looking for something I could build.  Not because I really wanted to publish an app, what I was looking for was something I could use as a learning tool.  A learning tool not just for me, but something I could use to illustrate concepts and features to others.&lt;/p&gt;

&lt;p&gt;What I wanted was something (a domain) people could understand quickly and easily but still allow me to incorporate as many of the features Windows 8 had to offer.&lt;/p&gt;

&lt;p&gt;Like many others I know, I like to listen to music while I'm working.  So one day I started up the Music app that came with Windows 8 and found it a bit frustrating to use.  If there was a way to do a playlist, I couldn't find it (remember this was in the days of the Beta, the app is a bit different now).&lt;/p&gt;

&lt;p&gt;After a short time messing around with it I decided this was the type of app I'd been looking for.  It ticked all of the following boxes for things I wanted to learn more about:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Reading/writing files&lt;/li&gt;
&lt;li&gt;Rendering grouped lists, with semantic zoom&lt;/li&gt;
&lt;li&gt;Touch interactions/manipulations&lt;/li&gt;
&lt;li&gt;Tiles and pinning&lt;/li&gt;
&lt;li&gt;Settings&lt;/li&gt;
&lt;li&gt;Background execution&lt;/li&gt;
&lt;li&gt;Search &lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;Phase 2 - Grooving along&lt;/h2&gt;

&lt;p&gt;So with great enthusiasm I set off building my imaginatively named Jukebox application, and in not too long had the core features roughly working and I could list and play the music in my music library.  After a few months of tinkering in my spare time I had working examples of all of the things on my list.&lt;/p&gt;

&lt;h2&gt;Phase 3 - First an app, then a framework&lt;/h2&gt;

&lt;p&gt;This was the point at which Orienteer was born.  Throughout the development of the app I had built and used controller based navigation, because that's what I liked from my WPF days and time spent with the Magellan Navigation Framework.  In order to be able to reuse this code I started refactoring it out, dare I say "into a framework".&lt;/p&gt;

&lt;p&gt;As a quick aside, Orienteer had a different name at that stage.  I originally called it Slab, and it was originally going to contain far more than it does today.  For example, it originally contained the PresentationBus, before I pulled that out and made it into its own library.&lt;/p&gt;

&lt;h2&gt;Phase 4 - "Why not have both?"&lt;/h2&gt;

&lt;p&gt;During the evolution of Orienteer I also started doing mobile development for Windows Phone 8, and iOS and Android, using Xamarin and Xamarin Forms.  So the question I then had was "Do I stick with Windows 8 (tablet) or do I go mobile?".  Given that Windows 8, Windows Phone 8 and Xamarin Forms are all XAML based, it turned out to be a case of "Why not have both?".&lt;/p&gt;

&lt;h2&gt;Windows 8 Jukebox&lt;/h2&gt;

&lt;p&gt;I've recently opened up the source code for the Jukebox app, you can find it &lt;a href="https://github.com/slewis74/Jukebox"&gt;on GitHub&lt;/a&gt;.  In a future post I'll go through each of the feature bullets points from above and talk about implementation specifics.&lt;/p&gt;

&lt;h2&gt;Reflections&lt;/h2&gt;

&lt;p&gt;So did I get what I wanted out of my journey with Orienteer?  Yes, absolutely.&lt;/p&gt;

&lt;p&gt;I learned a lot about Windows 8, mobile development in general and the satisfaction of publishing something of your own.&lt;/p&gt;

&lt;p&gt;A couple of things that stand out.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Publish early!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The core code for Orienteer was "almost ready" for a long time, but I was hesitant about releasing it. I think this was partly due to the origins in Windows 8.  With the lacklustre uptake of Windows 8 I started questioning whether Orienteer would be viable.  The inclusion of the other mobile platforms put those doubts to rest, but the delay cost me time in getting feedback and input from others.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do what you enjoy&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Yes, it sounds very cliche, but building Orienteer (and even the sample apps for that matter) has been something I've really enjoyed. Being the Product Owner is also a great learning experience.&lt;/p&gt;

&lt;h2&gt;Looking forward...&lt;/h2&gt;

&lt;p&gt;To Windows 10!&lt;/p&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2015/07/orienteer-winphone/</id><title type="text">Orienteer and Windows Phone</title><summary type="html">&lt;p&gt;Orienteer now has support for Windows Phone 8 Silverlight apps!&lt;/p&gt;
</summary><published>2015-06-30T14:00:00Z</published><updated>2015-06-30T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2015/07/orienteer-winphone/" /><content type="html">&lt;p&gt;Orienteer now has support for Windows Phone 8 Silverlight apps, and there's a &lt;a href="https://github.com/slewis74/Orienteer/tree/master/Samples/WinPhoneSample"&gt;sample app&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The bulk of the setup code is very similar to that of the Xamarin Forms applications, with the exception of the PhoneApplicationFrameAdapter.&lt;/p&gt;

&lt;h2&gt;PhoneApplicationFrameAdapter&lt;/h2&gt;

&lt;p&gt;To hook Orienteer into Xamarin Forms we use a custom NavigationPage, to hook in to Windows Phone we use an adapter that attaches to the PhoneApplicationFrame.  The code below shows how to initialize the adapter during the application initialization.&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;private IContainer _container;

private void InitializePhoneApplication()
{
    if (phoneApplicationInitialized)
        return;

    LetThereBeIoC();

    RootFrame = new PhoneApplicationFrame();
    RootFrame.Navigated += CompleteInitializePhoneApplication;
    RootFrame.NavigationFailed += RootFrame_NavigationFailed;
    RootFrame.Navigated += CheckForResetNavigation;

    InitFrameAdapter();

    phoneApplicationInitialized = true;
}

private async Task InitFrameAdapter()
{
    var adapter = _container.Resolve&amp;lt;IPhoneApplicationFrameAdapter&amp;gt;();
    adapter.PhoneApplicationFrame = RootFrame;
    await adapter.DoStartup();
}

private void LetThereBeIoC()
{
    var builder = new ContainerBuilder();
    builder.RegisterAssemblyModules(new[]
    {
        typeof(App).Assembly
    });

    _container = builder.Build();
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3&gt;Autofac registration&lt;/h3&gt;

&lt;p&gt;To register the adapter in Autofac you will need a registration similar to the following&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;builder
    .RegisterType&amp;lt;PhoneApplicationFrameAdapter&amp;gt;()
    .As&amp;lt;IPhoneApplicationFrameAdapter&amp;gt;()
    .WithParameter("viewRootNamespace", ViewRootNamespace)
    .WithParameter("baseFeatureFolder", "Features")
    .SingleInstance();
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Where:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;ViewRootNamespace is the same namespace used by the ViewLocator&lt;/li&gt;
&lt;li&gt;"Features" is the ViewRootNamespace's folder, relative to the root level of the application.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These values are used by the adapter to determine the correct XAML file to navigate to, when a ViewModelNavigationRequest is published.&lt;/p&gt;

&lt;h3&gt;Manifest Navigation Page&lt;/h3&gt;

&lt;p&gt;In the Windows Phone manifest there is a value for the default page to navigate to.  Orienteer doesn't use this value, it uses the NavigationStack's defaultRoute to determine the default route, and therefore page, to display.  It does however have to understand what the value is.&lt;/p&gt;

&lt;p&gt;The reason behind this is that the PhoneApplicationFrame itself will navigate to the specified page upon startup and cause issues with Orienteer's stack monitoring.&lt;/p&gt;

&lt;p&gt;You have a couple of options around this value:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Set the value to Orienteer, per the WinPhoneSample 
&lt;img src="http://blog.shannonlewis.me/images/wp8-manifest-navpage.png" width="360px" height="262px"/&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Set the value to be blank, and ignore the red text that appears in Visual Studio's manifest editor.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Choose your own custom value. In this scenario you will also need to set assign the custom value to the ManifestNavigationPage property of the adapter, for example in the Autofac registration you'd include something like  &lt;/p&gt;

&lt;pre&gt;&lt;code&gt;.WithProperty("ManifestNavigationPage", "MyCustomValue")
&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ol&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2015/06/orienteer/</id><title type="text">Orienteer</title><summary type="html">&lt;p&gt;Navigating in MVVM, which way do you go?&lt;/p&gt;
</summary><published>2015-06-14T14:00:00Z</published><updated>2015-06-14T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2015/06/orienteer/" /><content type="html">&lt;p&gt;Several years ago I set out into the world of mobile app development.  As a developer focused primarily in the Microsoft space, and having spent a good part of the last 8 years doing WPF development, Windows 8 and Windows Phone 8 apps seemed like a logical place to start.&lt;/p&gt;

&lt;p&gt;Over the years I've used numerous frameworks and tools, some of which I've grown to love, and others not so much.  One that I am particularly fond of, which was written by a friend and ex-colleague, is the &lt;a href="https://code.google.com/p/magellan-framework/"&gt;Magellan navigation framework for WPF&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The MVC style navigation and the removal of the navigation logic and data retrieval from the ViewModels makes so much sense to me, and when I started off into the mobile XAML world I found I was missing my controllers.  So over the course of the last 2-3years, and several projects, I've been slowly putting together something very similar, but a bit smaller and more mobile focused.  Introducing the result...&lt;/p&gt;

&lt;h2&gt;Orienteer&lt;/h2&gt;

&lt;p&gt;Orienteer is available as a &lt;a href="https://www.nuget.org/packages/Orienteer/"&gt;nuget package&lt;/a&gt;, and the &lt;a href="https://github.com/slewis74/Orienteer"&gt;project page&lt;/a&gt; can be found over on GitHub.&lt;/p&gt;

&lt;h3&gt;What's in the box?&lt;/h3&gt;

&lt;p&gt;Let's have a look at some of the core components and features.&lt;/p&gt;

&lt;h4&gt;Controllers and the Navigator&lt;/h4&gt;

&lt;p&gt;The core to navigating is a Navigator.  Any of the commands that need to trigger a navigation simply need to take a dependency on a Navigator, it provides the gateway to the controller actions.&lt;/p&gt;

&lt;p&gt;Controllers are controllers in the MVC, not the iOS sense, for those who've done iOS development.  An action can return a ViewModelResult, in order to navigate to the View (page) associated with that ViewModel.  An action can also return a DataActionResult, which only contains data (ViewModels can access these actions via the GetData methods on the Navigator).&lt;/p&gt;

&lt;p&gt;As a note, I haven't needed modals in the apps I've looked at so far, so no support for that yet but it's on the backlog.&lt;/p&gt;

&lt;h4&gt;ViewModel first navigation&lt;/h4&gt;

&lt;p&gt;As mentioned above, the controller actions can return a result identifying the ViewModel to navigate to, i.e. it uses ViewModel first navigation.  The View is located by naming convention, using a parallel hierarchy search from configured root namespaces for the Views and ViewModels.&lt;/p&gt;

&lt;p&gt;So the Views and ViewModels may reside in the same folder, in which case the root namespaces match, or they may reside below separate root level folders.  As an example of the latter, you might have ViewModels/Feature1/SomeViewModel.cs and it corresponding view might be Views/Feature1/SomeView.xaml   &lt;/p&gt;

&lt;h4&gt;Routing&lt;/h4&gt;

&lt;p&gt;Orienteer also supports routing similar to MVC.  For example, we could have a route that looks like the following&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;/contacts/search?name=smith
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This would call the Search action on the ContactsController, passing a value of 'smith' to the name parameter.&lt;/p&gt;

&lt;p&gt;There were 2 reasons for needing this, first is the routes for the current pages in the navigation stack are persisted, if required, so the stack can be restored on a restart of the app.&lt;/p&gt;

&lt;p&gt;Second, on Windows Phone and Windows 8 it's used for deep linking from pinned tiles.&lt;/p&gt;

&lt;h4&gt;Async support&lt;/h4&gt;

&lt;p&gt;The Navigator and Controller actions have full support for async/await. So you can NavigateAsync to a Controller action that is awaiting data retrieval.&lt;/p&gt;

&lt;h4&gt;Automatic Dispatching&lt;/h4&gt;

&lt;p&gt;The BindableBase and DispatchingObservableCollection both automatically dispatch all Changed events back onto the UI thread.  So if you have background data loads happening you never have to worry about dispatching.&lt;/p&gt;

&lt;p&gt;While we're on DispatchingObservableCollection, it also has support for LargeUpdates.  Once you start a Large update the CollectionChanged events are suppressed until you call complete, at which point a Reset is raised.  This is useful in scenarios where you know there'll be a large amount of items being added and you don't want the performance hit of a re-paint per Add.&lt;/p&gt;

&lt;h4&gt;NavigationFrame&lt;/h4&gt;

&lt;p&gt;In Windows 8 the inbuilt navigation Frame has some interesting behaviour regarding the way it caches or recreates Views when you navigate Back.  To work around this Orienteer has it's own NavigationFrame for Windows 8.&lt;/p&gt;

&lt;h4&gt;Xamarin Forms Support&lt;/h4&gt;

&lt;p&gt;Being XAML based, the navigation concepts that Orienteer uses fit in quite well with Xamarin Forms, so it's supported out of the box.&lt;/p&gt;

&lt;h3&gt;Sample Code&lt;/h3&gt;

&lt;p&gt;To help get going with Orienteer there is are samples included with the source.  At the time of writing this post the Xamarin Forms sample is complete.  Windows Phone and Windows 8 will be coming shortly.&lt;/p&gt;

&lt;p&gt;The samples currently all revolve around a simple app to display the music content on your device.  The Windows 8 sample that's coming will also include playing functionality, to help illustrate some more decoupling concepts and some more advanced uses of the &lt;strong&gt;&lt;a href="http://www.nuget.org/packages/Slew.PresentationBus/"&gt;PresentationBus&lt;/a&gt;&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The samples also use Autofac, being my container of choice, with illustration of how to configure it for use with Orienteer.  Orienteer itself has no direct dependency to Autofac though, so feel free to use your container of choice.&lt;/p&gt;

&lt;h4&gt;Windows Phone&lt;/h4&gt;

&lt;p&gt;If you run the Windows Phone app on the emulator you'll want to connect some music files to the emulator.  I'd recommend using the Windows Phone 8.1 Emulator.  In the SD Card configuration select a folder that contains some Music files and select Insert Card.  You'll get a prompt in the emulator at that point, select Yes and you're away.&lt;/p&gt;

&lt;p&gt;Note that the Windows Phone emulator resets its state on each restart, you have to select to Insert Card each time you restart it.&lt;/p&gt;

&lt;h4&gt;Android&lt;/h4&gt;

&lt;p&gt;Again, on the emulator you'll want some music files.  If you open an Android console you can use  &lt;/p&gt;

&lt;pre&gt;&lt;code&gt;adb push someMusicFolder /sdcard/
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This will copy the files onto the emulator.&lt;/p&gt;

&lt;h4&gt;iOS&lt;/h4&gt;

&lt;p&gt;On iOS, I haven't found a way to get music onto the emulator as yet.  The MusicProvider class for iOS currently returns some static data by default.  If you're running on a device then commenting out the static data code at the top of the ScanMusicLibraryFolder method.&lt;/p&gt;

&lt;h2&gt;Stay Tuned&lt;/h2&gt;

&lt;p&gt;While the samples should hopefully help those who are eager to give Orienteer a go, I'm also aiming to do some more detailed posts on setup and usage soon.  &lt;/p&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2015/05/viewcomposition/</id><title type="text">Composing views</title><summary type="html">&lt;p&gt;In case of massive XAML files, break here...&lt;/p&gt;
</summary><published>2015-05-24T14:00:00Z</published><updated>2015-05-24T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2015/05/viewcomposition/" /><content type="html">&lt;p&gt;A while back I talked about &lt;a href="http://blog.shannonlewis.me/2014/06/xaml-commands/"&gt;XAML and Commands&lt;/a&gt;, and I mentioned UI decoupling using something like an EventAggregator.  In that post I was focusing on the separation of the command logic into Command objects and how that decouples the UI implementation.  In this post we'll expore some more decoupling ideas.&lt;/p&gt;

&lt;h2&gt;View Composition&lt;/h2&gt;

&lt;p&gt;Something I commonly see in WPF and Xaml, where MVVM has been used, are massive ViewModels.  When you dig into these you'll usually find that there are in fact multiple view models that have all been jammed into the one class.  The tendency seems to come down to &lt;/p&gt;

&lt;pre&gt;&lt;code&gt;1 Page = 1 View = 1 ViewModel.
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;One of the things that initially seems nice about this arrangement is that we have easy access to everything we need.  There's lots of properties and command objects and all sorts of goodies within easy reach, just begging to be coupled together.  Where it leads though is an unhappy place.&lt;/p&gt;

&lt;p&gt;Ok, so we're in an unhappy place, where do we go?  We start to decouple the code and separate out the pieces. Let's say we've got a view that has a search panel, a panel with a list of results and a panel to display the details of whichever item in the list is selected. Each of these 3 concerns should have it's own View (user control) and ViewModel, the page's View and ViewModel are then host to the other 3. &lt;/p&gt;

&lt;p&gt;So this sounds good and we start pulling the code apart, let's start with the search panel. And with that we come to a screeching halt.  If the search code is in a separate ViewModel, how is it going to update the results list that is now in a different class?  We'll hit a similar thing when we split the list and the details for the selected item, how does the details panel know which item is selected? &lt;/p&gt;

&lt;p&gt;What we're seeing here is the difference between a coupled UI and a composed UI. A composed UI, as the name should suggest, is built up of components that are independent.  They do not have direct knowledge of what other components are in use around them, but we need a way for them to interact with the other components.&lt;/p&gt;

&lt;p&gt;I liken this to micro-service architecture, where you also have a number of services indirectly interacting with one another.  How do they achieve that interaction?  Commonly through a Service Bus of some kind, i.e. through messaging.  So maybe our ViewModels could interact through message to achieve a similar result?&lt;/p&gt;

&lt;h2&gt;Messaging and the PresentationBus&lt;/h2&gt;

&lt;p&gt;This is the scenario where the EventAggregator comes into play.  Now at this point let's clarify that despite the name, it doesn't actually Aggregate Events.  What it does is broker Events between a Publisher and a number of Subscribers.  I'm not sure on the exact origins of the name, but it's been commonly used for the message brokers in a number of frameworks (e.g. Unity, Caliburn Micro) for a very long time.&lt;/p&gt;

&lt;p&gt;As part of several side projects I've been working on, I've also built an implementation of an event broker that I called &lt;strong&gt;&lt;a href="http://www.nuget.org/packages/Slew.PresentationBus/"&gt;PresentationBus&lt;/a&gt;&lt;/strong&gt; (i.e. a Service Bus for the "Presentation Layer").&lt;/p&gt;

&lt;p&gt;In a future post I'll go through some more about PresentationBus and illustrate some more examples of its use.&lt;/p&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2015/03/mvvm/</id><title type="text">Model-View-ViewModel</title><summary type="html">&lt;p&gt;Don't forget the first M!&lt;/p&gt;
</summary><published>2015-03-26T14:00:00Z</published><updated>2015-03-26T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2015/03/mvvm/" /><content type="html">&lt;p&gt;As a consultant focused in the WPF and Mobile development spaces I've spent a lot of time in the world of MVVM.  I've seen lots of different frameworks and lots of different ideas around implementing MVVM.&lt;/p&gt;

&lt;p&gt;One thing that I've seen frequently cause confusion is the first M.  To help explain that statement, here are the typical ways I try to describe MVVM to people.&lt;/p&gt;

&lt;h2&gt;What is MVVM?&lt;/h2&gt;

&lt;p&gt;Model-View-ViewModel. That's what it's short for.&lt;/p&gt;

&lt;p&gt;MVVM is an adaptation of MVP and MVC, adjusted to play to the strengths of XAML's binding abilities. &lt;/p&gt;

&lt;p&gt;It also abstracts the visual behaviour away from the View and into a ViewModel, which is just a class at the end of the day, and in doing so it becomes possible to unit test the visual behaviour without an actual UI.&lt;/p&gt;

&lt;h2&gt;What is a Model?&lt;/h2&gt;

&lt;p&gt;A Model represents data.  The data may be a single entity, it might be an aggregate of multiple model entities.
Its responsibility is to hold the data and notify others when changes occur.  It is the Domain Model of your client app.&lt;/p&gt;

&lt;p&gt;A model object &lt;strong&gt;instance&lt;/strong&gt; may be shared between ViewModel instances.&lt;/p&gt;

&lt;h2&gt;What is a View Model?&lt;/h2&gt;

&lt;p&gt;A View Model represents the visual state of the data, and encapsulates the visual behaviour around that data.  It may project the data stored in a model (e.g. FullName may project "Surname, FirstName"), but it's responsibility is to hold the transient, visual state of the data.  IsSelected, IsChecked, IsEnabled, SelectedItem are examples of the types of properties on a ViewModel, they are not persisted but are important to the visualisation of the data.&lt;/p&gt;

&lt;p&gt;A ViewModel &lt;strong&gt;type&lt;/strong&gt; may be shared between Views, but &lt;a href="http://en.wikipedia.org/wiki/Here_be_dragons"&gt;here be dragons&lt;/a&gt;.  Only do this if the visual behaviour required &lt;strong&gt;is identical&lt;/strong&gt;.  If it isn't identical then you will be tempted into adding multiple personalities to the ViewModel, and violating the "Single Responsibility" principle. &lt;/p&gt;

&lt;h2&gt;What is a View?&lt;/h2&gt;

&lt;p&gt;A View presents the data to a user, through the use of ViewModels and Models.  A View can use a Model directly, if there is no requirement for visual state.&lt;/p&gt;

&lt;p&gt;A View may also consist of sub-Views.&lt;/p&gt;

&lt;h2&gt;Don't forget the first M!&lt;/h2&gt;

&lt;p&gt;So back to my earlier statement, many implementations I've seen have lots of Views and ViewModels, but not a Model in sight.  The first M (Model) gets neglected.&lt;/p&gt;

&lt;p&gt;When you dig deeper there usually are Models, but they've been called ViewModels.  How does the code get to this point?  I think it's often that the pattern is not well understood and the team get into the habit of just calling everything a ViewModel, then they start sharing something called a ViewModel (but is actually a Model) between Views, then they get into the habit of doing that, then they start sharing ViewModels that really are ViewModels between Views, then the dragons...&lt;/p&gt;

&lt;p&gt;So please, take the time to think about the first M, and avoid confusion by calling things what they actually are.&lt;/p&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2014/06/xaml-commands-and-user-feedback/</id><title type="text">Commands not executing, but why?</title><summary type="html">&lt;p&gt;So now that you've &lt;a href="http://blog.shannonlewis.me/2014/06/xaml-commands/"&gt;embraced commands&lt;/a&gt;, let's look at how we might provide a slightly better experience for users.&lt;/p&gt;
</summary><published>2014-06-11T14:00:00Z</published><updated>2014-06-11T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2014/06/xaml-commands-and-user-feedback/" /><content type="html">&lt;p&gt;So now that you've &lt;a href="http://blog.shannonlewis.me/2014/06/xaml-commands/"&gt;embraced commands&lt;/a&gt;, let's look at how we might provide a slightly better experience for users.&lt;/p&gt;

&lt;h2&gt;But why can't I execute?&lt;/h2&gt;

&lt;p&gt;In several WPF projects I've worked on we've had the requirement to feedback information to the user about why a button cannot currently execute.  Usually this will be due to some sort of validation condition failing.&lt;/p&gt;

&lt;p&gt;Enter a weakness in ICommand.  It provides&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;bool CanExecute(object value);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;for you to implement logic to determine whether the command can execute, given a parameter value.  The limitation is that you can't provide explanation as to why the command can't execute.&lt;/p&gt;

&lt;p&gt;For these scenarios, a base class along the lines of the following has worked well&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;public abstract class Command : ICommand, INotifyPropertyChanged
{
    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object value)
    {
        return Errors.Any() == false;
    }

    public bool HasErrors { get { return Errors.Any(); } }

    public virtual IEnumerable&amp;lt;string&amp;gt; Errors
    {
        get
        {
            return Enumerable.Empty&amp;lt;string&amp;gt;();
        }
    }

    public void Execute(object value)
    {
        if (!CanExecute(value))
            return;
        DoExecute(value);
    }

    protected abstract void DoExecute(object value);

    protected void RaiseCanExecuteChanged()
    {
        var handler = CanExecuteChanged;
        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
        NotifyChanged("HasErrors");
    }

    private void NotifyChanged(string propertyName)
    {
        // details intentionally left blank
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;So now with &lt;a href="http://msdn.microsoft.com/en-us/library/system.windows.controls.tooltipservice.showondisabled(v=vs.110).aspx"&gt;a little bit of trickery&lt;/a&gt;, you can bind up a button along the lines of&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;&amp;lt;Button
    Command="{Binding SomeCommand}" 
    ToolTipService.ShowOnDisabled="True" 
    Content="Disabled Button"&amp;gt;
    &amp;lt;Button.ToolTip Visibility="{Binding SomeCommand.HasErrors, Converter={StaticResource BooleanToVisibilityConverter}}"&amp;gt;
        &amp;lt;ToolTip&amp;gt;
            &amp;lt;ItemsControl ItemsSource="{Binding SomeCommand.Errors}"/&amp;gt;
        &amp;lt;/ToolTip&amp;gt;
    &amp;lt;/Button.ToolTip&amp;gt;
&amp;lt;/Button&amp;gt; 
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Depending on the application, and the likelihood of a large list of errors, you may also need to extend this to include some fixed sizing of the Tooltip and a ScrollViewer.&lt;/p&gt;

&lt;h2&gt;Mobile XAML&lt;/h2&gt;

&lt;p&gt;In mobile apps you don't have the same options for user feedback, Tooltips don't exist in that world, but the errors are likely to still be useful to the user. I'm still looking for a good solution in the mobile space, so stay tuned. &lt;/p&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2014/06/xamarin-android-parallels/</id><title type="text">Xamarin, Android and Parallels</title><summary type="html">&lt;p&gt;In this post I'll go through some options for debugging Android applications using Visual Studio and Xamarin Studio.&lt;/p&gt;
</summary><published>2014-06-10T14:00:00Z</published><updated>2014-06-10T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2014/06/xamarin-android-parallels/" /><content type="html">&lt;p&gt;In working on a recent project I tried a couple of different debugging configurations while developing an Android app.&lt;/p&gt;

&lt;p&gt;Following is what I learned along the way...&lt;/p&gt;

&lt;h2&gt;My setup&lt;/h2&gt;

&lt;p&gt;Before we go too far, I'm running a Mac Book Pro with Mavericks, Parallels 9 and a Windows 8.1 VM.  &lt;/p&gt;

&lt;h2&gt;Android Emulators&lt;/h2&gt;

&lt;p&gt;I'll jump ahead slightly here to talk emulators.  There are a couple of options available.&lt;/p&gt;

&lt;p&gt;The option most popular with others on the recent project team was the &lt;a href="http://www.genymotion.com/" title="GenyMotion"&gt;GenyMotion&lt;/a&gt; emulator.  It is fast and robust, but it isn't free.&lt;/p&gt;

&lt;p&gt;I went with the emulator that comes with the SDK and found it to be quite workable, assuming you have the Intel HAXM working and you don't move it onto your second display (&lt;a href="https://code.google.com/p/android/issues/detail?id=38371"&gt;if you do it will crash next time you start it&lt;/a&gt;).&lt;/p&gt;

&lt;h3&gt;Intel HAXM Hotfix&lt;/h3&gt;

&lt;p&gt;There was an issue with earlier versions of Intel HAXM when running in conjunction with Parallels.  The &lt;a href="https://software.intel.com/en-us/blogs/2013/11/06/intelr-haxm-hot-ffixes-for-os-x-mavericks-109-and-windows-81-available-for" title="hotfix"&gt;hotfix&lt;/a&gt; would previously have to be installed manually, but should now be included in the Intel HAXM installer.&lt;/p&gt;

&lt;p&gt;You'll know if it's not applied, because when you try to start an x86 based emulator image it'll hang the entire machine.&lt;/p&gt;

&lt;h2&gt;Installing the Android SDK(s)&lt;/h2&gt;

&lt;p&gt;The Xamarin installer will install the Android SDK with a number of defaults.&lt;/p&gt;

&lt;p&gt;A lesson I learned quickly was to be selective when installing support for extra versions.  If you simply tick the top level checkbox for a given API level, in the SDK Manager, it will install the SDK plus a number of emulator images, most of which you don't want.  I stuck to installing just the SDK and the x86 emulator image, in OS X.  In the Windows VM I had no intention of running the emulator so only installed the SDK itself. &lt;/p&gt;

&lt;h2&gt;Debugging&lt;/h2&gt;

&lt;p&gt;Debugging from Xamarin Studio in OS X was straightforward and worked without any real issue or special configuration.&lt;/p&gt;

&lt;h3&gt;Preserving data&lt;/h3&gt;

&lt;p&gt;Depending on your app, you may want to find the option to stop the app data from being cleared on each deploy.  The default setting, in both Xamarin Studio and Visual Studio, will clear all app data from the emulator/device every time you run the app.&lt;/p&gt;

&lt;p&gt;To changing the setting in Xamarin Studio:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Open the Preferences window&lt;/li&gt;
&lt;li&gt;Locate the Projects/Android settings&lt;/li&gt;
&lt;li&gt;Tick the "Preserve data/cache between application deploys"&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In Visual Studio:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Open the Tools/Options window&lt;/li&gt;
&lt;li&gt;Locate the Xamarin/Android settings&lt;/li&gt;
&lt;li&gt;Tick the "Preserve data/cache between application deploys"&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Parallels&lt;/h3&gt;

&lt;p&gt;For part of the project I developed using Xamarin Studio in OS X.  This worked, to a point, but for a number of reasons that I won't go into here I wanted to get back to Visual Studio.&lt;/p&gt;

&lt;p&gt;Being new to OS X, Xamarin and Android I came in with a steep learning curve in front of me.  Fortunately &lt;a href="http://chrisriesgo.com/android-emulator-debugging-from-parallels-to-os-x/"&gt;others had already blazed a trail&lt;/a&gt;, and &lt;a href="http://stackoverflow.com/questions/1754162/remote-debugging-with-android-emulator"&gt;with a little extra help&lt;/a&gt; I was well on the way.  &lt;/p&gt;

&lt;p&gt;Some further notes to this:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;When you need the Android SDK path is shown at the top of the Android SDK Manager window &lt;/li&gt;
&lt;li&gt;ADB ends up in your profile folder, in Windows. For me, the following script worked&lt;br/&gt;&lt;br/&gt;
&lt;strong&gt;"%USERPROFILE%\AppData\Local\Android\android-sdk\platform-tools\adb" kill-server&lt;/strong&gt; 
&lt;strong&gt;"%USERPROFILE%\AppData\Local\Android\android-sdk\platform-tools\adb" start-server&lt;/strong&gt;
&lt;strong&gt;"%USERPROFILE%\AppData\Local\Android\android-sdk\platform-tools\adb" devices&lt;/strong&gt;&lt;br/&gt;&lt;br/&gt;&lt;/li&gt;
&lt;li&gt;Xamarin Studio may sometimes require a Refresh to see the emulator correctly in the list of available devices.&lt;/li&gt;
&lt;li&gt;Visual Studio must be started after the emulator and all other SSH config.  It will only display the emulators it can see when it first starts.  &lt;strong&gt;If the list changes, you must restart Visual Studio&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;When configuring the SSH tunnel in PuTTY, the name/IP required can change depending on the network you are connected to.  If the Remote Login settings in OS X read like an IP address then use that IP address, if they don't then use the exact value shown.&lt;/li&gt;
&lt;li&gt;The Remote Login settings in OS X show &lt;em&gt;username&lt;/em&gt;@&lt;em&gt;machinename&lt;/em&gt;.  The &lt;strong&gt;&lt;em&gt;username&lt;/em&gt;@&lt;/strong&gt; can also be used in front of the IP/machine name in the PuTTY config, so you don't have to type the admin username each time you connect it, you'll just need to type the password. &lt;/li&gt;
&lt;/ul&gt;
</content></entry><entry><id>http://blog.shannonlewis.me/2014/06/xaml-commands/</id><title type="text">XAML and Commands</title><summary type="html">&lt;p&gt;A look at the pitfalls of DelegateCommands, and the alternatives.&lt;/p&gt;
</summary><published>2014-06-08T14:00:00Z</published><updated>2014-06-08T14:00:00Z</updated><link rel="alternate" href="http://blog.shannonlewis.me/2014/06/xaml-commands/" /><content type="html">&lt;p&gt;During a recent discussion with some developers new to XAML we got onto the topic of Commands.  During the discussion I went over some experiences from previous projects, with  emphasise on one particular pain point. &lt;/p&gt;

&lt;h2&gt;Where does it hurt?&lt;/h2&gt;

&lt;p&gt;One of the most common pain points I've come across relates to implementations around the command pattern.  The particular pain comes down to the &lt;a href="http://en.wikipedia.org/wiki/Command_pattern"&gt;receiver&lt;/a&gt; being a ViewModel.  This works for simple cases, but can quickly lead to bloating and the ViewModel taking on too many responsibilities/personalities.&lt;/p&gt;

&lt;p&gt;What does the manifestation look like?&lt;/p&gt;

&lt;h3&gt;DelegateCommand/RelayCommand&lt;/h3&gt;

&lt;p&gt;Included in many of the XAML/MVVM frameworks is the concept of a delegate command.  This is an implementation of ICommand that takes an Action to execute and a Func&lt;bool&gt; to determine CanExecute.  In the constructor you'll see something like this&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;SomeCommand = new DelegateCommand(() =&amp;gt; DoSomething(), () =&amp;gt; someCondition);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Then throughout your view model you will then find &lt;/p&gt;

&lt;pre&gt;&lt;code&gt;SomeCommand.RaiseCanExecuteChanged();
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;anywhere there's code that could change the result of the CanExecute condition.&lt;/p&gt;

&lt;h3&gt;No commands&lt;/h3&gt;

&lt;p&gt;A variation on this is used by Caliburn Micro.  What it does differently is that the ViewModel code doesn't use an ICommand derived command object.  It instead relies on methods and properties on the ViewModel, which it then wires to UI triggers and enabled properties.  There's no object to create, so no code in the constructor, but you'll find something like this&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;public bool CanDoSomething { get { return someCondition; } }

public void DoSomething()
{
    // execute stuff here
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Then throughout your view model you will then find &lt;/p&gt;

&lt;pre&gt;&lt;code&gt;NotifyChanged(() =&amp;gt; CanDoSomething);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;anywhere there's code that could change the result of the CanExecute condition.&lt;/p&gt;

&lt;h3&gt;So what's wrong with all this?&lt;/h3&gt;

&lt;p&gt;As I mentioned earlier, this is all workable for simple scenarios but gets unwieldy pretty quickly as screen complexity/number of commands increases.  I've come into code bases for complex WPF applications that have used this style of commands and it isn't fun, with ViewModels having blown out to thousands of lines of tangled code. &lt;/p&gt;

&lt;h3&gt;Embrace the commands&lt;/h3&gt;

&lt;p&gt;So my advice, embrace the commands.  Abstract the command functionality away from the ViewModel code and write command objects.&lt;/p&gt;

&lt;p&gt;Also, decouple the ViewModel and the Command implementation.  Commands that take a "parent" ViewModel in their constructor and wire themselves to events (think PropertyChanged, ObservableCollection.CollectionChanged etc) will lead to trouble and be hard to test.  I've had much better results through decoupling using an EventAggregator.  I'll save further discussion on decoupling and EventAggretion for another time.  &lt;/p&gt;
</content></entry></feed>