Infragistics WPF controls

Machine Learning tutorial: How to create a decision tree in RapidMiner using the Titanic passenger data set

 

 

Greetings! And welcome to another wam bam, thank you ma'am, mind blowing, flex showing, machine learning tutorial here at refactorthis.net!

This tutorial is based on a machine learning toolkit called RapidMiner by RapidI.  RapidMiner is a full featured Java based open source machine learning toolkit with support for all of the popular machine learning algorithms used in data analytics today.  The library supports supports the following machine learning algorithms (to name a few):

  • k-NN
  • Naive Bayes (kernel)
  • Decision Tree (Weight-based, Multiway)
  • Decision Stump
  • Random Tree
  • Random Forest
  • Neural Networks
  • Perception
  • Linear Regression
  • Polynomial Regression
  • Vector Linear Regression
  • Gaussian Process
  • Support Vector Machine (Linear, Evolutionary, PSO)
  • Additive Regression
  • Relative Regression
  • k-Means (kernel, fast)
  • And much much more!!
Excited yet?  I thought so!

How to create a decision tree using RapidMiner

When I first ran across screen shots of RapidMiner online, I thought to myself, "Oh boy.. I wonder how much this is going to cost...".  The UI looked so amazing.  It's like Visual Studio for Data Mining and Machine learning!  Much to my surprise, I found out that the application is open source and free!

Here is a quote from the RapidMiner site:

RapidMiner is unquestionably the world-leading open-source system for data mining. It is available as a stand-alone application for data analysis and as a data mining engine for the integration into own products. Thousands of applications of RapidMiner in more than 40 countries give their users a competitive edge.

I've been trying some machine learning "challenges" recently to sharpen my skills as a data scientist, and I decided to use RapidMiner to tackle the kaggle.com machine learning challenge called "Titanic: Machine Learning from Disaster" .  The data set is a CSV file that contains information on many of the passengers of the infamous Titanic voyage.  The goal of the challenge is to take one CSV file containing training data (the training data contains all attributes as well as the label Survived) and a testing data file containing only the attributes (no Survived label) and to predict the Survived label of the testing set based on the training set.

Warning: Although I'm not going to provide the complete solution to this challenge, I warn you, if you are working on this challenge, then you should probably stop reading this tutorial.  I do provide some insights into the survival data found in the training data set.  It's best to try to work the challenge out on your own.  After all, we learn by TRYING, FAILING, TRYING AGAIN, THEN SUCCEEDING.  I'd also like to say that I'm going to do my very best to go easy on the THEORY of this post..  I know that some of my readers like to get straight to the action :)  You have been warned..

 

Why a decision tree?

A decision tree model is a great way to visualize a data set to determine which attributes of a data set influenced a particular classification (label).  A decision tree looks like a tree with branches, flipped upside down..  Perhaps a (cheesy) image will illustrate..

 

After you are finished laughing at my drawing, we may proceed.......  OK

In my example, imagine that we have a data set that has data that is related to lifestyle and heart disease.  Each row has a person, their sex, age, Smoker (y/n), Diet (good/poor), and a label Risk (Less Risk/More Risk).  The data indicates that the biggest influence on Risk turns out to be the Smoker attribute.  Smoker becomes the first branch in our tree.  For Smokers, the next influencial attribute happens to be Age, however, for non smokers, the data indicates that their diet has a bigger influence on the risk.  The tree will branch into two different nodes until the classification os reached or the maximum "depth" that we establish is reached.  So as you can see, a decision tree can be a great way to visualize how a decision is derived based on the attributes in your data.

RapidMiner and data modeling

Ready to see how easy it is to create a prediction model using RapidMiner?  I thought so!

Create a new process

When you are working in RapidMiner, your project is known as a process.  So we will start by running RapidMiner and creating a new process.

 

 

The version of RapidMiner used in this tutorial is version 5.3.  Once the application is open, you will be presented with the following start screen.

 From this screen you will click on New Process

 You are presented with the main user interface for RapidMiner.  One of the most compelling aspects of Rapidminer is it's ease of use and intuitive user interface.  The basic flow of this process is as follows:

  • Import your test and training data from CSV files into your RapidMiner repository.  This can be found in the repository menu under Import CSV file
  • Once your data has been imported into your repository, the datasets can be dragged onto your process surface for you to apply operators
  • You will add your training data to the process
  • Next, you will add your testing data to the process
  • Search the operators for Decision Tree and add the operator
  • In order to use your training data to generate a prediction on your testing data using the Decision Tree model, we will add an "Apply Model" operator to the process.  This operator has an input that you will associate with the output model of your Decision Tree operator.  There is also an input that takes "unlearned" data from the output of your testing dataset.
  • You will attach the outputs of Apply Model to the results connectors on the right side of the process surface.
  • Once you have designed your model, RapidMiner will show you any problems with your process and will offer "Quick fixes" if they exists that you can double click to resolve.  
  • Once all problems have been resolved, you can run your process and you will see the results that you wired up to the results side of the process surface.
  • Here are screenshots of the entire process for your review

 Empty Process

 

Add the training data from the repository by dragging and dropping the dataset that you imported from your CSV file

 

Repeat the process and add the testing data underneath the training data

Now you can search in the operators window for Decision Tree operator.  Add it to your process.

The way that you associate the inputs and outputs of operators and data sets is by clicking on the output of one item and connecting it by clicking on the input of another item.  Here we are connecting the output of the training dataset to the input of the Decision Tree operator.

 

Next we will add the Apply model operator

Then we will create the appropriate connections for the model

Observe the quick fixes in the problems window at the bottom.. you can double click the quick fixes to resolve the issues.

You will be prompted to make a simple decision regarding the problem that was detected.  Once you resolve one problem, other problems may appear.  be sure to resolve all problems so that you can run your process.

Here is the process after resolving all problems.

 

Next, I select the decision tree operator and I adjust the following parameters:

Maximum Depth: change from 20 to 5.

check both boxes to make sure that the tree is not "pruned".

Once this has been done, you can Run your process and observe the results.  Since we connected both the model as well as the labeled result to the output connectors of the process, we are presented with a visual display of our Decision Tree (model) as well as the Test data set with the prediction applied.

(Decision Tree Model)

 

(The example test result set with the predictions applied)

 

As you can see, RapidMiner makes complex data analysis and machine learning tasks extremely easy with very little effort.

This concludes my tutorial on creating Decision Trees in RapidMiner.

Until next time,

 

Buddy James

 



Add comment

  Country flag


  • Comment
  • Preview
Loading

About the author

My name is Buddy James.  I'm a Microsoft Certified Solutions Developer from the Nashville, TN area.  I'm a Software Engineer, an author, a blogger (http://www.refactorthis.net), a mentor, a thought leader, a technologist, a data scientist, and a husband.  I enjoy working with design patterns, data mining, c#, WPF, Silverlight, WinRT, XAML, ASP.NET, python, CouchDB, RavenDB, Hadoop, Android(MonoDroid), iOS (MonoTouch), and Machine Learning. I love technology and I love to develop software, collect data, analyze the data, and learn from the data.  When I'm not coding,  I'm determined to make a difference in the world by using data and machine learning techniques. (follow me at @budbjames).  

Related links

Month List

refactorthis.net | How to keep your WPF UI responsive and report progress during a long running task. C# and asynchronous multithreading.
Infragistics WPF controls

How to keep your WPF UI responsive and report progress during a long running task. C# and asynchronous multithreading.

WPF Succinctly Download

 

 

The problem

Have you ever had to execute a bit of code that took an extremely long time to complete?  If so, I'm sure you've noticed that your user interface becomes unresponsive.  You can't use any controls on the form until the process completes.  This is extremely problematic and makes for a poor user experience.

The cause

This problem is because you have executed a synchronous block of code on the same thread as the user interface.  The user interface will not be able to respond to any user action until the synchronous method has completed.

Let's look at an example that illustrates the execution of a synchronous method executing on the user interface thread.

The example

 

This example is very simple.  It's a WPF application with two buttons.  

One of the buttons will start a long running for loop and the other button opens a MessageBox and

displays a message to let you know that the UI is active.

When you click the button to start the long running process, try to click the other button.  

You will notice that you are unable to click the button to show the message box.

 

Here's the MainWindow.xaml markup

<Window x:Class="SynchronousExecution.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid Width="111" Height="118">
        <Button Content="Start Process" Height="23" HorizontalAlignment="Left" Margin="10,10,0,0" Name="btnStartProcess" VerticalAlignment="Top" Width="89" Click="btnStartProcess_Click" />
        <Button Content="Try to click me" Height="23" HorizontalAlignment="Left" Margin="10,43,0,0" Name="btnTryMe" VerticalAlignment="Top" Width="89" Click="btnTryMe_Click" />
    </Grid>
</Window>

 

And here is the code behind MainWindow.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Threading;

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

        private void btnStartProcess_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Starting the long process.  Try to click the button below.");
            for (var loopCounter = 0; loopCounter < 500; loopCounter++)
            {
                Thread.Sleep(100);
            }
            MessageBox.Show("The process has ended.");
        }

        private void btnTryMe_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("User interface is responding!");
        }
    }
}

Download  SynchronousExecution.zip (52.38 kb)

The solution

The solution to this problem is to spawn a new thread to execute the long running task.  By placing the execution on a seperate thread, this leaves the main UI thread free to interact with the user's input.

Reporting progress 

If you execute a long running task, you usually want to let your users know about the progress of the task.  A control to assist with this is the progressbar control.  

The WPF progress bar control inherits from the RangeBase class.  The control contains the following properties to control how the progress is displayed to the user.

Minimum The minimum value of the Value property.
Maximum The maximum value of the Value property.
SmallChange The value in which the Value property is incremented.
Value The current value position between the Minimum and Maximum property.

Multithreading concerns

Multithreading is a complex topic and is beyond the scope of this article.  However, there are a few concerns that you must be aware of if you plan to access values on the UI thread from the worker thread.

The System.Windows.Threading.Dispatcher object is used to execute code on the UI thread from the executing worker thread.  The Dispatcher object has the BeginInvoke method which will execute an asynchronous delegate on the thread in which the dispatcher object was created.  So by using the dispatcher object from the user interface code you are able to access the user interface controls from your worker thread.

We'll take a look at another example that will bring all of these concepts together to illustrate executing a long running task on a seperate thread with a progress bar that updates the user interface via the Dispatcher object.

The example

The example is a WPF application.  The main window contains the following controls;

lstRandomValues A ListBox control that will hold random values that are generated during the long running process. The pupose of this control is to illustrate the responsiveness of the user interface during the long running process.
prgProgress A ProgressBar control that will illustrate the progress of the long running task. The ProgressBar is hidden by default. It's shown when the long running process begins and is hidden again when the process has ended or is canceled.
txtProgress A TextBox control that displays the long running process percentage of completion.
btnCancel A Button control that will cancel the long running process and in turn hide the progress bar and progress textbox.
btnInteract A Button control that will launch a MessageBox to illustrate the responsiveness of the UI while the long running process is executing.
btnBegin A Button control that will begin the long running process.

And here is the code 

Window1.xaml

<Window x:Class="RandomNameSpace.ViewModels.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="400" Width="400">    
        <!-- Parent Grid -->
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition />
                <RowDefinition />
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition />
                <ColumnDefinition />
            </Grid.ColumnDefinitions>
            <ListBox Grid.Row="0" Grid.Column="0" Name="lstRandomValues" Grid.ColumnSpan="2" />
        
            <Grid Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2">
                <Grid.RowDefinitions>
                    <RowDefinition />
                    <RowDefinition />
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition />
                    <ColumnDefinition />
                </Grid.ColumnDefinitions>
                
                <Border Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2" x:Name="bdrProgress" Visibility="Hidden" Background="Azure" CornerRadius="10" BorderBrush="DarkGray" BorderThickness="1" HorizontalAlignment="Center" VerticalAlignment="Center">
                    <StackPanel>
                        <Grid Margin="5">
                            <ProgressBar x:Name="prgProgress" Width="200" Height="20" Minimum="0" Maximum="1" />
                            <TextBlock x:Name="txtProgress" HorizontalAlignment="Center" VerticalAlignment="Center" />
                        </Grid>
                        <Button x:Name="btnCancel" Content="Cancel" HorizontalAlignment="Right" Margin="3" Click="btnCancel_Click" />
                    </StackPanel>
                </Border>
                
                <Button Grid.Row="1" Grid.Column="1" x:Name="btnInteract" HorizontalAlignment="Center"  Content="Interact with UI" Click="btnInteract_Click" Height="23.96" />
                <Button Grid.Row="1" Grid.Column="0" x:Name="btnBegin" HorizontalAlignment="Left"  Content="Start Long Process" Click="btnBegin_Click"  Height="23.96" Margin="35,33.27,0,33.27" />
            </Grid>
        </Grid>
</Window>

Window1.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Threading;
using System.Windows.Threading;


namespace RandomNameSpace.ViewModels
{
	/// <summary>
	/// Interaction logic for Window1.xaml
	/// </summary>
	public partial class Window1 : Window 
	{
        private bool IsCanceled = false;

        private RandomViewModel _viewModel;

        public RandomViewModel ViewModel
        {
            get { return _viewModel; }
            set { _viewModel = value; }
        }

		public Window1()
		{
			InitializeComponent();
            PrepareViewModel();
		}

        private void PrepareViewModel()
        {
            ViewModel = new RandomViewModel();

            this.lstRandomValues.DisplayMemberPath = "Value";
            this.lstRandomValues.DataContext = ViewModel;
            this.lstRandomValues.ItemsSource = ViewModel;
        }

		private void btnBegin_Click(object sender, RoutedEventArgs e)
		{
            BeginProcess();
		}

		private void btnInteract_Click(object sender, RoutedEventArgs e)
		{
            MessageBox.Show("Interaction!");
		}

		private void btnCancel_Click(object sender, RoutedEventArgs e)
		{
            CancelProcess();
		}

        public void BeginProcess()
        {
            bdrProgress.Visibility = System.Windows.Visibility.Visible;
            DisableBeginButton();
            Action StartLoop;
            StartLoop = () => DoLongRunningProcess();

            Thread t;

            t = new Thread(StartLoop.Invoke);
            t.Start();
        }

        public void CancelProcess()
        {
            this.IsCanceled = true;
            Thread.Sleep(1500);
            ClearListBox();
            EnableBeginButton();
        }

        private void ClearListBox()
        {
            Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.ViewModel.Clear(); }, null);
        }

        private void DoLongRunningProcess()
        {
            for (var loopCounter = 0.0; loopCounter < 1.0; loopCounter = loopCounter + .1)
            {
                if (!IsCanceled)
                {
                    //add a random number to the viewmodel collection to be bound to the listview
                    Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.ViewModel.AddValue(1564); }, null);

                    UpdateProgressBar(loopCounter);
                    Thread.Sleep(2000);
                }
                else
                {
                    break;
                }
            }

            IsCanceled = false;

            ClearListBox();

            MessageBox.Show("Completed");

            EnableBeginButton();
            HideProgressBar();

        }

        private void EnableBeginButton()
        {
            Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.btnBegin.SetValue(Button.IsEnabledProperty, true); }, null);
        }

        private void DisableBeginButton()
        {
            Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.btnBegin.SetValue(Button.IsEnabledProperty, false); }, null);
        }

        private void UpdateProgressBar(double value)
        {
            Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.prgProgress.SetValue(ProgressBar.ValueProperty, value); }, null);
            Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.txtProgress.SetValue(TextBlock.TextProperty, (value * 100).ToString()); }, null);
        }

        private void HideProgressBar()
        {
            Dispatcher.BeginInvoke(DispatcherPriority.Background, (SendOrPostCallback)delegate { this.bdrProgress.SetValue(Border.VisibilityProperty, Visibility.Collapsed); }, null);
        }
	}
}

 

RandomValue.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace RandomNameSpace.ViewModels
{
    public class RandomValue : INotifyPropertyChanged
    {
        private int _value;

        public int Value
        {
            get
            {
                return _value;
            }
            set
            {
                if (_value != value)
                    _value = value;

                OnPropertyChanged("Value");
            }
        }


        public event PropertyChangedEventHandler PropertyChanged;

        public void OnPropertyChanged(string propertyName)
        {
            var handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

RandomViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;

namespace RandomNameSpace.ViewModels
{
    public class RandomViewModel : ObservableCollection<RandomValue>
    {
        public RandomViewModel() : base() {}

        public void AddValue(int value)
        {
            Random rnd = new Random();
            var calculatedValue = (value * rnd.Next(3000));

            this.Add(new RandomValue { Value = (calculatedValue) });
        }
    }
}

Here is the entire solution for download. 

WPFAsyncProgressBarMVVM.zip (77.39 kb)  

This concludes the article.  Thank you for taking the time to read it!

Until next time...

~/Buddy James

kick it on DotNetKicks.com

 

 



Pingbacks and trackbacks (1)+

Add comment

  Country flag


  • Comment
  • Preview
Loading

About the author

My name is Buddy James.  I'm a Microsoft Certified Solutions Developer from the Nashville, TN area.  I'm a Software Engineer, an author, a blogger (http://www.refactorthis.net), a mentor, a thought leader, a technologist, a data scientist, and a husband.  I enjoy working with design patterns, data mining, c#, WPF, Silverlight, WinRT, XAML, ASP.NET, python, CouchDB, RavenDB, Hadoop, Android(MonoDroid), iOS (MonoTouch), and Machine Learning. I love technology and I love to develop software, collect data, analyze the data, and learn from the data.  When I'm not coding,  I'm determined to make a difference in the world by using data and machine learning techniques. (follow me at @budbjames).  

Related links

Month List

refactorthis.net | How to list local Windows System Services and their dependencies using WPF DataBinding and MVVM
Infragistics JQuery controls

How to list local Windows System Services and their dependencies using WPF DataBinding and MVVM

The example

I wrote this example in an effort to monitor the Windows Services that are installed on my system at any given time.  I decided to kill two birds with one stone and learn a bit about MVVM, DataBinding, and WPF in the process.  I'll start by showing you a class diagram of the solution.  I'll follow with providing all of the source code snippets for your review.  Finally, I'll explain the application and provide a link for you to download the complete solution.

Malware and Windows Services

I've learned that Malware as well as viruses often disguise themselves as "normal" Windows services to take advantage of automatic/delayed starting capabilities.  Windows services are also an ideal place for degenerates to place their malicious code because most of your typical Windows users don't take a second look here for problems.

Windows Services

And here is a screen shot of the application that I wrote to explore the many facets of WPF databinding.

As you can see, the application simply lists all Windows service names, Display names, and their dependent services.  The goal was to perform a google search when double clicking a service (you can add this if you like, it's probably about 3 lines of code).  I thought I could easily google suspicious looking services to find any problematic applications. 

The ServiceController[] array

The .NET framework class library contains an object that describes a Windows Service and it's called the ServiceController.  I decided that I would create a wrapper around this ServiceContoller array with my own object so that I could implement ObservableCollection<> as well as INotifyPropertyChanged to make the collection of objects play nice with WPF's DataBinding.  Here is a class diagram that illustrates the entire application.

 

 

 

 

 

 

 

 

 

And here's the code....

WindowsService.cs (a wrapper to ServiceController)

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace WindowsServiceMonitor
{
    /// <summary>
    /// The purpose of this class is to serve as a wrapper class to the
    /// ServiceController.  This class provides propertychange notification 
    /// to allow databinding with WPF.
    /// </summary>
    public class WindowsService : INotifyPropertyChanged
    {
        #region "private members"

        private string _serviceName;
        private string _displayName;
        private WindowsServiceCollection _dependentServices;

        #endregion

        #region "INotifyPropertyChanged event"

        /// <summary>
        /// Facilities property change notification and WPF databinding 
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// This method is called when any property is changed
        /// </summary>
        /// <param name="info"></param>
        protected void OnPropertyChanged(string info)
        {
            PropertyChangedEventHandler handler = PropertyChanged;

            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

        #endregion

        #region "Public constructors"

        /// <summary>
        /// Overloaded constructor
        /// </summary>
        /// <param name="serviceName">The short name of the service</param>
        /// <param name="displayName">The friendly display name of the service</param>
        /// <param name="dependentServices">An observable collection of windows services</param>
        public WindowsService(string serviceName, string displayName, WindowsServiceCollection dependentServices)
        {
            _serviceName = serviceName;
            _displayName = displayName;
            _dependentServices = dependentServices;
        }

        /// <summary>
        /// Default constructor
        /// </summary>
        public WindowsService() { }

        #endregion

        #region "Public Properties"

        /// <summary>
        /// The short name of the service
        /// </summary>
        public string ServiceName
        {
            get { return _serviceName; }
            set
            {
                _serviceName = value;
                OnPropertyChanged("ServiceName");
            }
        }

        /// <summary>
        /// The friendly display name of the service
        /// </summary>
        public string DisplayName
        {
            get { return _displayName; }
            set
            {
                _displayName = value;
                OnPropertyChanged("DisplayName");
            }
        }

        /// <summary>
        /// An observable collection of windows services
        /// </summary>
        public WindowsServiceCollection DependentServices
        {
            get { return _dependentServices; }
            set
            {
                _dependentServices = value;
                OnPropertyChanged("DependentServices");
            }
        }

        /// <summary>
        /// override the object tostring method to return the service name
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return _serviceName;
        }

        #endregion
    }
}

WindowsServiceCollection.cs (A wrapper to ServiceController[] which inherits ObservableCollection<>)

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.ServiceProcess;
using System.Text;

namespace WindowsServiceMonitor
{
    /// <summary>
    /// A WPF friendly collection of WindowsService objects
    /// </summary>
    public class WindowsServiceCollection : ObservableCollection<WindowsService>
    {
        /// <summary>
        /// Default constructor
        /// </summary>
        public WindowsServiceCollection() : base() { }

        /// <summary>
        /// Add all windows services to this collection object
        /// </summary>
        /// <param name="windowsServices">The current windows service</param>
        public void LoadServices(ServiceController[] windowsServices)
        {
            
            try
            {
                //loop through each root level service dependency
                foreach (ServiceController service in windowsServices)
                {
                    //create a new WPF friendly windows service object
                    WindowsService windowsService;
                    windowsService = new WindowsService();

                    //Set the service properties
                    windowsService.ServiceName = service.ServiceName;
                    windowsService.DisplayName = service.DisplayName;

                    try
                    {
                        //recursivley build the service depdencies
                        WindowsServiceCollection.BuildDependentServiceHierarchy(windowsService, service.DependentServices);
                    }
                    catch (InvalidOperationException exception)
                    {
                        //I've received unable to open ___ service on the computer  
                        //I'll use an empty catch until i research the issue.
                        var operationExceptionMessage = exception.Message;
                    }
                    catch (Exception exception)
                    {
                        var generalExceptionMessage = exception.Message;
                    }

                    //add the WPF friendly service to this Observable service collection
                    Add(windowsService);
                }
            }
            catch (Exception ex)
            {
                var message = ex.Message;
            }

            
        }

        /// <summary>
        /// recursivley build the service depdencies
        /// </summary>
        /// <param name="service">the WFP friendly windows service wrapper</param>
        /// <param name="dependentServices">The collection of windows service dependencies</param>
        /// <returns></returns>
        public static void BuildDependentServiceHierarchy(WindowsService service, ServiceController[] dependentServices)
        {
            //if we don't have a valid service object
            if (service == null)
                //alert the caller
                throw new NullReferenceException("Invalid service object.");

            //loop through each dependent service
            foreach (ServiceController dependentService in dependentServices)
            {
                WindowsService dependentServiceWrapper = new WindowsService(dependentService.ServiceName, dependentService.DisplayName, new WindowsServiceCollection());

                //build the current service's dependencies
                WindowsServiceCollection.BuildDependentServiceHierarchy(dependentServiceWrapper, dependentService.DependentServices);

                //if the depdent services collection has yet to be created
                if (service.DependentServices == null)
                    //create a new observable collection of dependent services
                    service.DependentServices = new WindowsServiceCollection();

                //add the depdency to the wrappers dependents collection
                service.DependentServices.Add(dependentServiceWrapper);
            }
        }
    }
}

ServiceMonitorViewModel.cs (This is the ViewModel and it basically loads all ServiceContoller classes and builds the corresponding WindowsServiceCollections and serves the data to the WPF MainWindow view via DataBinding.)

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.ServiceProcess;
using System.Windows.Data;

namespace WindowsServiceMonitor.ViewModels
{
    public class ServiceMonitorViewModel
    {
        private ServiceController[] _serviceControllers;
        private WindowsServiceCollection _observableServices;


        public ServiceMonitorViewModel()
        {
            this.LoadSystemServices();

            this.ObservableWindowsServices = new WindowsServiceCollection();
            this.ObservableWindowsServices = _observableServices;
            //this.ObservableWindowsServices.Source = _observableServices;
        }

        public WindowsServiceCollection ObservableWindowsServices { get; set; }

        private void LoadSystemServices()
        {
            _serviceControllers = ServiceController.GetServices();

            _observableServices = new WindowsServiceCollection();
            _observableServices.LoadServices(_serviceControllers);
        }
    }
}

And finally we have MainWindow.xaml which is our WPF view.

<Window x:Class="WindowsServiceMonitor.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:viewModel="clr-namespace:WindowsServiceMonitor.ViewModels"
        Title="MainWindow" SizeToContent="WidthAndHeight"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008" mc:Ignorable="d">

        <Window.Resources>
            <viewModel:ServiceMonitorViewModel x:Key="WindosServicesViewModel"/>
            
        <Style TargetType="ListBoxItem">
            <Setter Property="FontFamily" Value="Verdana" />
            <Setter Property="FontSize" Value="12"></Setter>
            <Setter Property="Padding" Value="10"></Setter>
        </Style>
        
        <DataTemplate x:Key="DetailTemplate">
            <Border  Margin="20"
              BorderBrush="Aqua" BorderThickness="1" Padding="8">
                <Grid ScrollViewer.CanContentScroll="True" ScrollViewer.HorizontalScrollBarVisibility="Auto" 
                      ScrollViewer.VerticalScrollBarVisibility="Auto" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" >
                    <Grid.RowDefinitions>
                        <RowDefinition/>
                        <RowDefinition/>
                        <RowDefinition/>
                    </Grid.RowDefinitions>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition/>
                        <ColumnDefinition/>
                    </Grid.ColumnDefinitions>
                    <TextBlock Grid.Row="0" Grid.Column="0" Text="Service Name:"/>
                    <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Path=ServiceName}"/>
                    <TextBlock Grid.Row="1" Grid.Column="0" Text="Display Name:"/>
                    <TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding Path=DisplayName}"/>
                    <TextBlock Grid.Row="2" Grid.Column="0" Text="Dependents:"/>
                    <ListBox Name="lstDependentServices" Grid.Row="2" Grid.Column="1" IsSynchronizedWithCurrentItem="True"  ItemsSource="{Binding Path=DependentServices}" DisplayMemberPath="DisplayName" />
                </Grid>
            </Border>
        </DataTemplate>
    </Window.Resources>
    <DockPanel>
        <StackPanel>
            <TextBlock>Windows Services</TextBlock>
            <ListBox Name="lstServices" HorizontalAlignment="Stretch" Height="300" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Center" VerticalAlignment="Stretch" DataContext="{Binding Source={StaticResource WindosServicesViewModel}}" ScrollViewer.VerticalScrollBarVisibility="Auto" IsSynchronizedWithCurrentItem="True" 
                     ItemsSource="{Binding ObservableWindowsServices}"/>
        
        
            <TextBlock Grid.Row="0" Grid.Column="0" Text="Service Properties" />
            <ContentControl DataContext="{Binding Source={StaticResource WindosServicesViewModel}}" Content="{Binding ObservableWindowsServices}"
                            ContentTemplate="{StaticResource DetailTemplate}"  />
        </StackPanel>

    </DockPanel>
</Window>

And that about wraps it up.  Please note that each WindowsServiceCollection contains a WindowsServiceCollection of dependent windows services.  Also notice the many different uses of WPF databinding.  We bind the root level WindowsServiceCollection to a ListView and we bind  some TextBlocks to it's selection so that way when the user clicks to select a service, we can display a details view of the specified service.

That's pretty much all there is to it.  I can say that I learned a lot by writing this application and I had a lot of fun as well.

Here is a link to the entire solution for you to download WindowsServiceMonitor.zip (2.92 mb) 

I hope you have enjoyed this post and I hope you will check back soon!

Thanks!

~/Buddy James

 

  kick it on DotNetKicks.com

 



Pingbacks and trackbacks (1)+

Add comment

  Country flag


  • Comment
  • Preview
Loading

About the author

My name is Buddy James.  I'm a Microsoft Certified Solutions Developer from the Nashville, TN area.  I'm a Software Engineer, an author, a blogger (http://www.refactorthis.net), a mentor, a thought leader, a technologist, a data scientist, and a husband.  I enjoy working with design patterns, data mining, c#, WPF, Silverlight, WinRT, XAML, ASP.NET, python, CouchDB, RavenDB, Hadoop, Android(MonoDroid), iOS (MonoTouch), and Machine Learning. I love technology and I love to develop software, collect data, analyze the data, and learn from the data.  When I'm not coding,  I'm determined to make a difference in the world by using data and machine learning techniques. (follow me at @budbjames).  

Related links

Month List