INTRODUCTION: Over a two part series I introduced how to use an MVC pattern with a Universal Windows App.  That example simply gave a list of Game of Thrones characters for display.  I’ve extended the example to also allow editing those characters in a details page.  I’ve also added a singleton to control application state and to perform navigation.

Let’s first take a look at the Singleton, which I’ve named ApplicationSingleton.  I’ve moved the instantiation of the Controller to this class as well as removed code in App.xaml.cs that used the Frame.  Instead of a navigation frame, our Singleton will assign instances of MainPage and DetailsPage to the Window Context as the user navigates the app.

EXAMPLE: App.xaml.cs Changes

        /// <summary>
        /// Invoked when the application is launched normally by the end user.  Other entry points
        /// will be used such as when the application is launched to open a specific file.
        /// </summary>
        /// <param name="e">Details about the launch request and process.</param>
        protected override void OnLaunched(LaunchActivatedEventArgs e)
        {

#if DEBUG
            if (System.Diagnostics.Debugger.IsAttached)
            {
                this.DebugSettings.EnableFrameRateCounter = false;
            }
#endif

            Window.Current.Content = ApplicationSingleton.Instance.MainPage;
            Window.Current.Activate();
        }

Now that we have the App setting it’s initial page with the Singleton, we’ll take a look at the Singleton itself.

EXAMPLE: ApplicationSingleton Code

using System.Collections.Generic;
using Windows.UI.Xaml;
using SharpNinja.Controllers.People;
using SharpNinja.Models.BlogEntities;
using SharpNinja.Utilities.MvcBasics;

namespace SharpNinja.UI.Windows10Sample2.Singletons
{
    internal class ApplicationSingleton
    {
        private ApplicationSingleton()
        {
            _personsController.Initialize(new List<IView> { _listView, _detailsView });
        }

        private readonly static ApplicationSingleton _instance = 
            new ApplicationSingleton();

        public static ApplicationSingleton Instance => _instance;

        private readonly PersonsController _personsController = 
            new PersonsController();

        private MainPage _listView = new MainPage();
        public MainPage MainPage => _listView;

        private DetailsPage _detailsView = new DetailsPage();
        public DetailsPage DetailsView => _detailsView;

        private AppState _state = AppState.List;

        public void Navigate(AppState state, params object[] values)
        {
            switch (state)
            {
                case AppState.List:
                    Window.Current.Content = _listView;
                    _state = AppState.List;
                    break;

                case AppState.Details:
                    Window.Current.Content = _detailsView;
                    var person = values[0] as Person;
                    _detailsView.InvokeLoadPersonModel(person.Name);
                   _state = AppState.Details;
                    break;
            }
        }
    }

    internal enum AppState { List, Details }
}

The Singleton is used to not only manage the state of the application, but to instantiate and register the pages of the application with the PersonsController (which has not changed at all to accomodate the changes in the User Interface).

The MainPage had to be updated a little to handle the SelectedItemChanged event so that users can click a character and open their details.

EXAMPLE: MainPage.xaml Changes

        <ListView Name="lstResults" Grid.Row="1" HorizontalAlignment="Stretch"
                  SelectionChanged="Selector_OnSelectionChanged">

EXAMPLE: MainPage.xaml.cs Changes

        private void Selector_OnSelectionChanged(object sender, 
            SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 1)
            {
                var person = e.AddedItems[0] as Person;

                ApplicationSingleton.Instance.Navigate(AppState.Details, person);
            }
        }

We now have our navigation and MainPage changes.  We can now look at the XAML for our DetailsPage.

EXAMPLE: DetailsPage.xaml Code

<Page
    x:Class="SharpNinja.UI.Windows10Sample2.DetailsPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:SharpNinja.UI.Windows10Sample2"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" 
    >
    <Page.TopAppBar>
        <AppBar Height="50" Background="Black" IsOpen="True">
            <AppBarButton Height="50" Name="btnBack" Click="ButtonBase_OnClick">
                <TextBlock Margin="5 0 5 0">Back</TextBlock>
            </AppBarButton>
        </AppBar>
    </Page.TopAppBar>
    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <Border Grid.Row="0" BorderThickness="5" CornerRadius="7" 
                Background="Blue" BorderBrush="Yellow" 
                Margin="10 5 10 7" Padding="8" Name="nameBorder">
            <TextBlock Text="{Binding Name, Mode=OneWay}"/>
        </Border>

        <Grid Grid.Row="1" Margin="10 5 10 7">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="*" />
            </Grid.RowDefinitions>
            <TextBlock Grid.Row="0" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="5 0 5 0">First Name:</TextBlock>
            <TextBox Grid.Row="0" VerticalAlignment="Center" Grid.Column="1" Text="{Binding FirstName, Mode=TwoWay}"/>
            <TextBlock Grid.Row="1" VerticalAlignment="Center" Grid.Column="0" HorizontalAlignment="Left" Margin="5 0 5 0">Last Name:</TextBlock>
            <TextBox Grid.Row="1" VerticalAlignment="Center" Grid.Column="1" Text="{Binding LastName, Mode=TwoWay}"/>
            <TextBlock Grid.Row="2" VerticalAlignment="Center" Grid.Column="0" HorizontalAlignment="Left" Margin="5 0 5 0">Date of Birth:</TextBlock>
            <DatePicker Grid.Row="2" VerticalAlignment="Center" Grid.Column="1" Date="{Binding DateOfBirth, Mode=TwoWay}"/>
            <TextBlock Grid.Row="3" VerticalAlignment="Center" Grid.Column="0" HorizontalAlignment="Left" Margin="5 0 5 0">Age:</TextBlock>
            <TextBlock Grid.Row="3" VerticalAlignment="Center" Grid.Column="1" Text="{Binding Age, Mode=OneWay}"/>
        </Grid>
        <Border Grid.Row="2" BorderThickness="5" CornerRadius="7" 
                Background="Blue" BorderBrush="Yellow" 
                Margin="10 7 10 7" Padding="8" Name="statusBorder">
            <TextBlock Name="lblStatus"/>
        </Border>

    </Grid>
</Page>

EXAMPLE: DetailsPage.xaml.cs Code

using System;
using Windows.UI;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media;
using SharpNinja.Controllers.People.Views;
using SharpNinja.Models.BlogEntities;
using SharpNinja.UI.Windows10Sample2.Singletons;

namespace SharpNinja.UI.Windows10Sample2
{
    public sealed partial class DetailsPage : Page, IPersonDetailsView
    {
        public DetailsPage()
        {
            this.InitializeComponent();
        }

        private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
        {
            ApplicationSingleton.Instance.Navigate(AppState.List);
        }

        // From IView 
        public void SetStatus(string message, bool isError)
        {
            lblStatus.Text = message;
            statusBorder.Background =
                new SolidColorBrush(isError ? Colors.Red : Colors.Blue);
        }

        public Person Model { get; set; }
        public event EventHandler<string> LoadPersonModel;

        internal void InvokeLoadPersonModel(string name)
        {
            LoadPersonModel?.Invoke(this, name);
            DataContext = Model;
        }

    }
}

The DetailsPage uses two way binding on the Model property (an instance of the Person object defined in the IPersonDetailsView interface).  This allows the UI and Model to be updated in real time.  Because the List page uses the ObservableCollection to hold all of the instances of the Person object, even the MainPage gets updated so when you go back to it, you see the changes immediately without having to refresh the search!

CONCLUSION: Using the MVC pattern along with a Singleton is a very, very powerful method of engineering any application.  Here we see it working beautifully with a Universal Windows Application, but it could just as well be WinForms or ASP.Net.  MVVM is not the end-all-be-all of XAML-based development.  Whether you are using Silverlight, WPF, Windows Store App, or Universal Windows App, you can still use the tried and true MVC, and you get a more portable framework to boot.

INTRODUCTION: Today I got a call from a recruiter looking to fix a big problem that a client is having with bad decisions being made with about code, deployment, testing… you name it.  I expressed to the executive that called me for an interview that nothing was going to get fixed without culture change, to which he said not to worry about that because he was ordering culture change and it would happen.  Well, a pack of developers can be like a pack of teenagers… They will see any change to the way they do things as an attack on their self-worth, which then leads into a ton of passive-aggressive behavior on the part of the group that will either lead to mass firings or an organizational change near the top. 

If you want culture change in a development group, it takes time, patience and a leader with a vision that the pack will buy into.  It takes someone with the background in the new techniques that the pack can hang their hat on.  It takes concrete examples of how to accomplish the new techniques.  Finally, it takes someone willing to teach the new techniques in a way that the developers take ownership in the learning and not just being lectured to.

CONCLUSION: I politely turned down the position.  I don’t want to waste their time because the pack would just see me as part of the problem of the forced changes and I don’t care to spend my time fighting a battle like that.

INTRODUCTION In part one of this series we built a simple MVC framework for our GoT character search engine. Now let’s look at how we can expand it actually provide a user interface via a Windows 10 Universal App. BTW, all of the code for this app is on GitHub.

We’ve already defined the first interface for our app, IPersonListView in the previous article.

Now we’ll implement that view with our MainPage of our search engine app.

EXAMPLE 1

using System;
using System.Collections.ObjectModel;
using System.Linq;
using Windows.UI;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media;
using SharpNinja.Models.BlogEntities;
using SharpNinja.UI.Windows10Sample.Controllers;
using SharpNinja.UI.Windows10Sample.Views;

namespace SharpNinja.UI.Windows10Sample
{
    public sealed partial class MainPage : Page, IPersonsListView
    {
        // Our controller
        private PersonsController _controller = new PersonsController();

        public MainPage()
        {
            this.InitializeComponent();

            // Initialize the controller
            _controller.Initialize(new []{this});
        }

        // From IView 
        public void SetStatus(string message, bool isError)
        {
            lblStatus.Text = message;
            statusBorder.Background = 
                new SolidColorBrush(isError ? Colors.Red : Colors.Blue);
        }

        // The Persons list
        public ObservableCollection<Person> PersonsList { get; set; }

        // Tells the controller to find the persons based on the 
        // provided partial string.
        public event EventHandler<string> FindPersons;

        // Bind the results;
        public void BindPersonsList()
        {
            // Views are responsible for sorting data
            // based on user preferences.
            lstResults.ItemsSource = 
                new ObservableCollection<Person>(
                    PersonsList.OrderBy(x => x.Name));
        }

        private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
        {
            // Use null propagation to invoke our search.
            FindPersons?.Invoke(sender, txtSearchTerm.Text);
        }
    }
}

Here’s the XAML…

EXAMPLE 2

<Page
    x:Class="SharpNinja.UI.Windows10Sample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:SharpNinja.UI.Windows10Sample"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <Border Grid.Row="0" BorderThickness="5" CornerRadius="7"
                Background="DarkBlue" BorderBrush="Yellow" 
                Margin="10 7 10 7" Padding="8">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto"/>
                    <ColumnDefinition Width="*" />
                    <ColumnDefinition Width="Auto" />
                </Grid.ColumnDefinitions>
                <TextBlock Grid.Column="0">Search Term</TextBlock>
                <TextBox Grid.Column="1" Name="txtSearchTerm"/>
                <Button Grid.Column="2" Click="ButtonBase_OnClick">GO!</Button>
            </Grid>
        </Border>
        <ListView Name="lstResults" Grid.Row="1" HorizontalAlignment="Stretch" >
            <ListView.ItemTemplate>
                <DataTemplate>
                    <Grid HorizontalAlignment="Stretch">
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="Auto"/>
                            <ColumnDefinition Width="20" />
                            <ColumnDefinition Width="*"/>
                        </Grid.ColumnDefinitions>
                        <TextBlock Grid.Column="0" 
                                   Text="{Binding Path='Age', Mode=OneWay}" />
                        <TextBlock Grid.Column="2" 
                                   Text="{Binding Path='Name', Mode=OneWay}" 
                                   HorizontalAlignment="Stretch"/>
                    </Grid>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
        <Border Grid.Row="2" BorderThickness="5" CornerRadius="7" 
                Background="Blue" BorderBrush="Yellow" 
                Margin="10 7 10 7" Padding="8" Name="statusBorder">
            <TextBlock Name="lblStatus"/>
        </Border>
    </Grid>
</Page>

In future articles I’ll spend more time on this example and how all of the databinding works, but for now know that the basic flow is that the user types some text to search for, clicks “GO” and then the controller finds the matching Persons and tells the View to bind to it.

CONCLUSION: Really that’s about it for the search engine. In the next post in this series we’ll look at extending the application to include a second page for entering or editing people.

INTRODUCTION: Today a user asked a very good question on Stack Overflow about adding more data to a DataGrid as the user nears the bottom of the grid.

It was an easy enough problem to solve, so I whipped together a sample app and am writing this article to further document it.

First, you’re XAML (this time in WPF format) needs to be defined. Normal instinct would be to let the DataGrid show it’s scrollbar as necessary, but in this case you should suppress that behavior and use a ScrollViewer because the ScrollView allows you to capture a ScrollChange event and the DataGrid does not.

EXAMPLE 1

<Window x:Class="GridExpansion.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:GridExpansion"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <ScrollViewer VerticalScrollBarVisibility="Visible" 
                      ScrollChanged="ScrollViewer_OnScrollChanged" 
                      PreviewMouseWheel="UIElement_OnPreviewMouseWheel">
            <DataGrid x:Name="dg" VerticalScrollBarVisibility="Disabled"></DataGrid>
        </ScrollViewer>
            <DataGrid x:Name="dg" VerticalScrollBarVisibility="Disabled"></DataGrid>
        </ScrollViewer>
    </Grid>
</Window>

Next, we need our code behind which contains the code to initialize our grid and add more data on demand.

EXAMPLE 2

using System;
using System.Data;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;

namespace GridExpansion
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            CreateTable();

            dg.AutoGenerateColumns = true;
            dg.ItemsSource = EmployeeDataTable.DefaultView;
        }

        private DataTable employeeDataTable;
        private bool _addingData;

        public DataTable EmployeeDataTable
        {
            get { return employeeDataTable; }
            set
            {
                employeeDataTable = value;
            }
        }

        private void CreateTable()
        {
            EmployeeDataTable = new DataTable("EmployeeDataTable");
            EmployeeDataTable.Columns.Add("Row", typeof(int));
            EmployeeDataTable.Columns.Add("0", typeof(string));
            EmployeeDataTable.Columns.Add("1", typeof(string));
            EmployeeDataTable.Columns.Add("2", typeof(string));
            EmployeeDataTable.Columns.Add("3", typeof(string));
            EmployeeDataTable.Columns.Add("4", typeof(string));
            EmployeeDataTable.Columns.Add("5", typeof(string));
            EmployeeDataTable.Columns.Add("6", typeof(string));
            EmployeeDataTable.Columns.Add("7", typeof(string));
            EmployeeDataTable.Columns.Add("8", typeof(string));
            EmployeeDataTable.Columns.Add("9", typeof(string));

            GetNewData();
            GetNewData();
            GetNewData();
        }

        private void GetNewData()
        {
            for (int i = 0; i < 20; i++)//Adding 20 DataRows
            {
                var theRow = employeeDataTable.NewRow();
                theRow[0] = employeeDataTable.Rows.Count;
                for (int j = 1; j < 11; j++)
                {
                    theRow[j] = j % 2 == 0 ? "a" : "b";
                }
                Application.Current.Dispatcher.Invoke(DispatcherPriority.Background, new Action(() =>
                {
                    employeeDataTable.Rows.Add(theRow);
                }));
            }
        }

        private void ScrollViewer_OnScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            var sv = sender as ScrollViewer;

            if (sv != null && !_addingData)
            {
                if (sv.ScrollableHeight - e.VerticalOffset == 0)
                {
                    _addingData = true;
                    GetNewData();
                    _addingData = false;
                }
            }
        }

        private void UIElement_OnPreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            ScrollViewer scv = (ScrollViewer)sender;
            scv.ScrollToVerticalOffset(scv.VerticalOffset - e.Delta);
            e.Handled = true;
        }
    }
}

CONCLUSION: The magic is in the ScrollViewer_OnScrollChanged event handler. We simply check if the scrollable height == the vertical height of the event args and if they are the same then we add more data.

Posted in WPF.

INTRODUCTION: There are a lot of reasons to use real apps on the desktop:

  • Chrome can use over 1GB of RAM and runs continuously.  Universal apps typically do not.
  • Over 70% of the web is written in PHP.  Of those, 81% are vulnerable to attack.  Universal apps are almost impossible to attack without physical access to your desktop.
  • Tabbed browsers are like poor window managers trying to co-opt good window managers.
  • Universal apps don’t need a bloated javascript engine to get 1/10th of the performance of compiled code.

CONCLUSION:  For many applications, the web is the way to go.  Think corporate presence, branding, publishing, etc.  Written in a responsible manner these can be good netizens.  We’ve already seen in the phone segment that people prefer apps that are tailored to their application, not just another bootstrap website running in a browser that depends on a far-away server for everything.  It’s time for a Desktop Renaissance and Universal Apps can get us there.

INTRODUCTION: Previously, I wrote about the MVC design pattern.  That article focused on the mechanics of the pattern more than a realistic implementation.  In this article we’ll look at a full MVC application, starting with the Model, the Controller and finally the Views as implemented in a Windows 10 Universal Application.

THE MODEL: For this application we’ll use a fairly complex Person class that has normal CRUD properties as well as some data-centric properties such as calculating age from the Date of Birth property.  This will give you a good idea of the kind of classes you can make for serialization using your preferred format (SOAP, JSON, Binary, etc).

EXAMPLE 1 – THE PERSON CLASS

using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;

namespace SharpNinja.Models.BlogEntities
{
    [DataContract]
    public class Person : INotifyPropertyChanged
    {
        private string _firstName;
        private string _lastName;
        private DateTime _dateOfBirth = DateTime.Today;

        public Person(string firstName, string lastName)
        {
            FirstName = firstName;
            LastName = lastName;
        }

        [DataMember]
        public string FirstName
        {
            get { return _firstName; }
            set
            {
                if (value == _firstName) return;
                _firstName = value;
                OnPropertyChanged();
            }
        }

        public string Name => $"{FirstName} {LastName}";

        [DataMember]
        public string LastName
        {
            get { return _lastName; }
            set
            {
                if (value == _lastName) return;
                _lastName = value;
                OnPropertyChanged();
            }
        }

        [DataMember]
        public DateTime DateOfBirth
        {
            get { return _dateOfBirth; }
            set
            {
                if (value.Equals(_dateOfBirth)) return;
                _dateOfBirth = value;
                OnPropertyChanged();
                OnPropertyChanged(nameof(Age));
                OnPropertyChanged(nameof(IsChild));
            }
        }

        public int Age => (DateTime.Today - DateOfBirth).Days / 365;

        public bool IsChild => Age < 18;

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

The Person class has a lot of nifty features. It implements INotifyPropertyChanged so that views that are databinding capable are able to bind to the values of the Person. Another feature is that it’s marked as a DataContract which allows it to be easily serialized. The properties representing the serializable content are also decorated with the DataMember attribute.

Just a quick note… See that method invocation of PropertyChanged? That’s the correct way to call an event using Null Propagation.

VIEWS PART 1: Our Person Model now needs to be interacted with in some way. There are two main use cases for our application: get a list of Person instances and editing a Person. For this tutorial we will focus on getting the list of Person instances by create a simple search engine for Game of Thrones characters.

The view for the search engine will define a list of Person objects, an event for telling the Controller that a search is required, and a callback method for the Controller to let the View know that new results are ready.

EXAMPLE 2

using System;
using System.Collections.ObjectModel;
using SharpNinja.Models.BlogEntities;
using SharpNinja.Utilities.MvcBasics;

namespace SharpNinja.UI.Windows10Sample.Views
{
    public interface IPersonsListView : IView
    {
        ObservableCollection<Person> PersonsList { get; set; }

        event EventHandler<string> FindPersons;

        void BindPersonsList();
    }
}

That’s all that’s necessary to define the View, and that’s all that’s necessary to implement the Controller.

BTW, all of the source code for this article (and the next one) is located on GitHub. You will see some code there that’s not 100% pertinent to this article.

THE CONTROLLER: The Controller is the heart of the application. It is responsible for persisting and retrieving Models from the data store, for enforcing the rules of the application, and for providing non-UI oriented logic. In our app, the Controller will act as the search engine, accepting a partial match string as a parameter for the FindPersons event of the IPersonsListView.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using SharpNinja.Models.BlogEntities;
using SharpNinja.UI.Windows10Sample.Views;
using SharpNinja.Utilities.MvcBasics;

namespace SharpNinja.UI.Windows10Sample.Controllers
{
    public class PersonsController : IController
    {
        private List<Person> _fakePersonsDatabase;

        public PersonsController()
        {
            _fakePersonsDatabase = new List<Person>();

            _fakePersonsDatabase.Add(new Person("John", "Snow") { DateOfBirth = new DateTime(1995, 2, 28) });
            _fakePersonsDatabase.Add(new Person("Ned", "Stark") { DateOfBirth = new DateTime(1971, 1, 15) });
            _fakePersonsDatabase.Add(new Person("Stannis", "Barathian") { DateOfBirth = new DateTime(1952, 12, 8) });
            _fakePersonsDatabase.Add(new Person("Aria", "Stark") { DateOfBirth = new DateTime(2003, 7, 10) });
        }

        #region IDisposable
        protected bool _isDisposed = false;
        public void Dispose()
        {
            if (!_isDisposed)
            {
                // Dispose of resources

                _isDisposed = true;
            }
        }
        #endregion

        #region Views
        private readonly List<IView> _views = new List<IView>();
        private IPersonsListView _personsListView = null;

        protected IPersonsListView PersonsListView
        {
            get
            {
                return _personsListView ??
                       (_personsListView = _views.FirstOrDefault(x => x is IPersonsListView) as IPersonsListView);
            }
        }
        #endregion

        public void Initialize(ICollection<IView> views)
        {
            foreach (var view in views)
            {
                if (view is IPersonsListView &amp;&amp; !_views.Any(x => x is IPersonsListView))
                {
                    _views.Add(view);

                    PersonsListView.FindPersons -= PersonsListViewOnFindPersons;
                    PersonsListView.FindPersons += PersonsListViewOnFindPersons;
                }
            }
        }

        private void PersonsListViewOnFindPersons(object sender, string s)
        {
            if (PersonsListView != null)
            {
                var search = s.ToLower();
                var results =
                    _fakePersonsDatabase.Where(
                        x => x.FirstName.ToLower().Contains(search) || x.LastName.ToLower().Contains(search)).ToList();

                if (results.Count > 0)
                {
                    PersonsListView.PersonsList = new ObservableCollection<Person>(results);

                    PersonsListView.BindPersonsList();
                    PersonsListView.SetStatus($"Found {results.Count} persons matching {s}", false);
                }
                else
                {
                    PersonsListView.SetStatus($"No results found for {s}.", true);
                }
            }
        }
    }
}

There’s a lot going on here, so let’s start at the top. Our application implements a fake datastore of GoT characters. This is not typical of a real app, but I didn’t want to introduce database code into this first example.

Next, you will see a property named PersonsListView. This property makes it possible to use a strongly typed instance of the View while only having to do the type checking once.

Our compulsary Initialize method adds IView instances to the controller. It knows about the events exposed in the View and appropriately registers to those events.

Finally, our event handler method does the searching of the fake datastore and places the data in the View’s PersonsList and invokes the View’s BindPersonsList call-back method.

STOPPING POINT:  That’s enough for this article.  The next article will bring it all together into a Windows 10 Universal App.  See you then!

INTRODUCTION: There are a couple of reasons to have public classes that need to control their own instantiation. First, is the Singleton pattern (read more here), but another is when you have an object that gets instantiated through reflection. Enter that Factory Pattern. Objects that implement the Factory Pattern are known as Object Factories. There may be any number of objects they create, from reflected types to deserialized data. Object Factories are responsible for making sure the object you request is instantiated correctly and ready to work.

A popular reason for the Factory Pattern is Dependency Injection (I will be doing an article on that in the near future). Essentially, Dependency Injection allows you to create an object from a definition stored in some configuration, and assign it to some known contract. The class that does this magic is the Object Factory.

Another popular reason for the Factory Pattern is to allow a polymorphic sub-class to provide it’s own instantiation signature that is separated from the construction of the class hierarchy. An example is in the Entity Framework where the implementation classes for entities contained a CreateEntityName static method to instantiate the entity and ensure that all non-nullable fields are maintained without having to overload the constructor, which is left as a default constructor so that the user could optionally use the object initializer.

Of the two use cases above, the Dependency Injection technique is the most useful, but for sake of brevity, I will use a simple Object Factory to show the mechanics of the pattern in C#.

EXAMPLE

public static class MyFactory
{
  public static ConstructedObject MakeObject(string data)
  {
    // Don't allow an instance without data!
    if(data == null) throw new ArgumentNullException("Data cannot be null.");

    // Create the object and return it.
    return new ConstructedObject { Data = data };
  }
}

// Our constructible class.
public class ConstructedObject
{
  // No constructor defined, so Data must be initialized
  // by the factory.
  public string Data {get; set;}
}

public class Program
{
  public static void Main(string[] args)
  {
    // Check for arguments.
    if(args.Any())
    {
      // Contrived attempt to get a null data.
      var data = args[0].Length > 0 ? args[0] : null;
    
      try 
      {
        // Create the object.
        var obj = MyFactory.MakeObject(data);
 
        // Yay!
        Console.WriteLine(obj.Data);
      }
      catch(ArgumentNullException ane)
      {
        // Boo!
        Console.WriteLine(ane.ToString());
      }
    }
  }
}

CONCLUSION: The Factory Pattern is one of the most useful utility patterns around. In just this simple example I’ve shown how an Object Factory can apply business rules as an object is instantiated. Another use case could be a class with a static method to provide an instance if and only if certain preconditions are met. This would allow the return of a null object instead of throwing an exception. Really, the sky’s the limit for what can be accomplished with a Factory Pattern implementation!