Strategy_SortEntries_Classes.cs

Go to the documentation of this file.

 
 
// The Strategy pattern is used when a choice of multiple different but
// related algorithms can be made at startup time.  The implementation of each
// related algorithm exposes the same interface so as to hide the details of
// implementation from the calling program.
//
// This module holds the sorting strategies used on a list of EntryInformation
// objects.
 
using System;
using System.Collections.Generic;
 
namespace DesignPatternExamples_csharp
{
    internal interface ISortEntries
    {
        void Sort(List<EntryInformation> entries);
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class Strategy_SortEntries_ByName : ISortEntries
    {
        bool _reversedSort;
 
        public Strategy_SortEntries_ByName(bool reversedSort)
        {
            _reversedSort = reversedSort;
        }
 
 
        public void Sort(List<EntryInformation> entries)
        {
            // Take advantage of C#'s lambda/anonymous function capability
            // to specify the sorting criteria so we don't have to define a
            // separate method for this.  This is where lambdas really shine.
            entries.Sort(delegate (EntryInformation left, EntryInformation right)
            {
                return (_reversedSort) ? right.Name.CompareTo(left.Name) : left.Name.CompareTo(right.Name);
            });
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class Strategy_SortEntries_ByAge : ISortEntries
    {
        bool _reversedSort;
 
        public Strategy_SortEntries_ByAge(bool reversedSort)
        {
            _reversedSort = reversedSort;
        }
 
 
        public void Sort(List<EntryInformation> entries)
        {
            // Take advantage of C#'s lambda/anonymous function capability
            // to specify the sorting criteria so we don't have to define a
            // separate method for this.  This is where lambdas really shine.
            entries.Sort(delegate (EntryInformation left, EntryInformation right)
            {
                return (_reversedSort) ? right.Age.CompareTo(left.Age) : left.Age.CompareTo(right.Age);
            });
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    internal class Strategy_SortEntries_ByHeight : ISortEntries
    {
        bool _reversedSort;
 
        public Strategy_SortEntries_ByHeight(bool reversedSort)
        {
            _reversedSort = reversedSort;
        }
 
 
        public void Sort(List<EntryInformation> entries)
        {
            // Take advantage of C#'s lambda/anonymous function capability
            // to specify the sorting criteria so we don't have to define a
            // separate method for this.  This is where lambdas really shine.
            entries.Sort(delegate (EntryInformation left, EntryInformation right)
            {
                return (_reversedSort) ? right.Height.CompareTo(left.Height) : left.Height.CompareTo(right.Height);
            });
        }
    }
 
 
    internal static class Strategy_SortEntries_ClassFactory
    {
        internal static ISortEntries Create(Strategy_ShowEntries_Class.SortOptions sortOption, bool reversedSort)
        {
            ISortEntries sortEntries;
 
            switch(sortOption)
            {
                case Strategy_ShowEntries_Class.SortOptions.ByName:
                    sortEntries = new Strategy_SortEntries_ByName(reversedSort);
                    break;
 
                case Strategy_ShowEntries_Class.SortOptions.ByAge:
                    sortEntries = new Strategy_SortEntries_ByAge(reversedSort);
                    break;
 
                case Strategy_ShowEntries_Class.SortOptions.ByHeight:
                    sortEntries = new Strategy_SortEntries_ByHeight(reversedSort);
                    break;
 
                default:
                    {
                        string message = string.Format("Unrecognized sort option: {0}", sortOption);
                        throw new ApplicationException(message);
                    }
            }
 
            return sortEntries;
        }
    }
}