YamlDotNet - Serializing an object graph | C# Online Compiler

YamlDotNet - Serializing an object graph by Anonymous

// The original method is used to check whether the user has provided a dataset name and if that
// name already exists as a dataset. If the former is true and the latter is false, then it returns
// true.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Program
{
    public class Program
    {
        public static TextBox txtDatasetName;
        public static Window MatchLevelWindow;

        public static void Main(string[] args)
        {
            // Set the test values to return false
            Program.txtDatasetName = new TextBox("MyDataset");
            Program.MatchLevelWindow = new Window(
                new List<string>() {
                    "DatasetA",
                    "DatasetB",
                    "MyDataset"
                }
            );
            // Run the original method
            Console.WriteLine(checkDatasetName());
            // Run the new method
            Console.WriteLine(checkDatasetNameNew());
            // Run the parameterised new method
            Console.WriteLine(checkDatasetNameParameterised(MatchLevelWindow.lsbSelectDataset.Items, txtDatasetName.Text));

            // Set the test values to return true
            Program.txtDatasetName = new TextBox("MyDatasetName");
            Program.MatchLevelWindow = new Window(
                new List<string>() {
                    "DatasetA",
                    "DatasetB",
                    "MyDataset"
                }
            );
            // Run the original method
            Console.WriteLine(checkDatasetName());
            // Run the new method
            Console.WriteLine(checkDatasetNameNew());
            // Run the parameterised new method
            Console.WriteLine(checkDatasetNameParameterised(MatchLevelWindow.lsbSelectDataset.Items, txtDatasetName.Text));

            // Set the test values to include null
            Program.txtDatasetName = new TextBox(null);
            Program.MatchLevelWindow = new Window(
                new List<string>() {
                    "DatasetA",
                    "DatasetB",
                    "MyDataset",
                    null
                }
            );
            // Run the original method
            try { Console.WriteLine(checkDatasetName()); }
            catch { Console.WriteLine("Error!"); }
            // Run the new method
            Console.WriteLine(checkDatasetNameNew());
            // Run the parameterised new method
            Console.WriteLine(checkDatasetNameParameterised(MatchLevelWindow.lsbSelectDataset.Items, txtDatasetName.Text));
        }

        // The old method (copied directly from BitBucket)
        private static bool checkDatasetName()
        {
            // Create and set output bools
            bool isDatasetName = false;
            bool isDatasetNameExist = false;

            // Adjust the boolean value of matchSetNameCheck depending on whether or not a match set name has been entered
            if (txtDatasetName.Text.Length != 0)
            {
                isDatasetName = true;
            }

            // Loop through every dataset in the match level window and check if the textbox text matches one of them (case insensitive)
            foreach (string datasetName in MatchLevelWindow.lsbSelectDataset.Items)
            {
                if (datasetName.ToLower() == txtDatasetName.Text.ToLower())
                {
                    isDatasetNameExist = true;
                    break;
                }
            }

            return isDatasetName && !isDatasetNameExist;
        }

        // The new method
		// What has improved?
		// - We no longer create new boolean variables each time the method is called
        //   (isDatasetName and isDatasetNameExist). Instead we directly return the boolean result
        //   of what we wish to check.
        // - Instead of checking for the length of the text we now call the in-built static String
        //   method IsNUllOrEmpty(). The advantage of this is that we can now pass null values
        //   safely without the program throwing an error.
        // - We've simplied the the foreach loop into a LINQ query (which applies ToLower() to each
        //   item in the collection) and call the Contains() method to search for the given string,
        //   which allows for null values in both the collection and the string
        // - Conditional-OR operator will return true if the first statement is true, without
        //   running the (more expensive; algorithm is O(n)) Contains() method. If false it will
        //   then continue to run the second statement.
        // - Using a nice application of De Morgan's law, we have simplied 4* operations
        //   (evaluation of first statement, evaluation of second statement, inversion of value of
        //   second statement and the conjunction of the values of both statements) to 3
        //   (evaluation of first statement, evaluation of second statement, disjunction of the
        //   values of both statements). This is, of course, ignoring the Conditional-OR which
        //   means we're sometimes only performing 2 operations.
        //   * This ia bit of a simplification... but, again is fine for our purposes. Modern
        //     compilers (especially C#'s Roslyn) will probably optimise this out anyway, but it's
        //     very well worth knowing about anyway! You may not even be working with a powerful
        //     compiler, and will have to implement many optimisations on your own. Even the best
        //     compilers will not optimise 90% of your code, given you decide to write it very
        //     poorly. So understanding basic optimisations like this really helps for any kind of
        //     optimisation. Not to mention, it's far more readable than the alternate!
        private static bool checkDatasetNameNew()
        {
            return !(
				String.IsNullOrEmpty(txtDatasetName.Text)
                || MatchLevelWindow.lsbSelectDataset.Items
                    .Select(x => x.ToLower())
                    .Contains(txtDatasetName.Text.ToLower())
			);
        }

        // The new parameterised method
        // What has improved?
        // - All improvements in checkDatasetNameNew()
        // - We can now generically apply this method to any input collection and string, rather
        //   than hardcoding them in (MatchLevelWindow.lsbSelectDataset.Items,
        //   txtDatasetName.Text).
        // - The method is far more readable thanks to the shorter parameter names.
        // - If we have to manipulate the collection and/or text multiple times in the method (we
        //   don't), we can simply use the reference to the original collection, rather than have
        //   the code traverse the object and its properties each time (again, this can be
        //   optimised without the parameterisation and compilers may optimise this out anyway, but
        //   is a lot easier this way).*
        //   * Disclaimer: this may not be how the referencing in C# is implemented and might be a
        //     false point, but is worth thinking about as an abstract point regardless.
        private static bool checkDatasetNameParameterised(ICollection<string> items, string text)
        {
            return !(
                String.IsNullOrEmpty(text)
                || items.Select(x => x.ToLower()).Contains(text.ToLower())
            );
        }
    }

    // Don't worry about the below. It's just to get the above to work without having to use the entire
    // WPF library and making loads of objects.

    public class Window
    {
        private ListBox _listBox;

        public Window(IList<string> items)
        {
            _listBox = new ListBox(items);
        }

        public ListBox lsbSelectDataset
        {
            get { return _listBox; }
        }
    }

    public class ListBox
    {
        private IList<string> _items;

        public ListBox(IList<string> items)
        {
            _items = items;
        }

        public IList<string> Items
        {
            get { return _items; }
        }
    }

    public class TextBox
    {
        private string _text;

        public TextBox(string text)
        {
            _text = text;
        }

        public string Text
        {
            get { return _text; }
        }
    }
}

​x
 
// The original method is used to check whether the user has provided a dataset name and if that
// name already exists as a dataset. If the former is true and the latter is false, then it returns
// true.
​
using System;
using System.Collections.Generic;
using System.Linq;
​
namespace Program
{
    public class Program
    {
        public static TextBox txtDatasetName;
        public static Window MatchLevelWindow;
​
        public static void Main(string[] args)
        {
            // Set the test values to return false
            Program.txtDatasetName = new TextBox("MyDataset");
            Program.MatchLevelWindow = new Window(
                new List<string>() {
                    "DatasetA",
                    "DatasetB",
                    "MyDataset"
                }
            );
            // Run the original method
            Console.WriteLine(checkDatasetName());
            // Run the new method
            Console.WriteLine(checkDatasetNameNew());
            // Run the parameterised new method
            Console.WriteLine(checkDatasetNameParameterised(MatchLevelWindow.lsbSelectDataset.Items, txtDatasetName.Text));
​
            // Set the test values to return true
            Program.txtDatasetName = new TextBox("MyDatasetName");
            Program.MatchLevelWindow = new Window(
                new List<string>() {
                    "DatasetA",
                    "DatasetB",
                    "MyDataset"
                }
            );
            // Run the original method
            Console.WriteLine(checkDatasetName());
            // Run the new method
            Console.WriteLine(checkDatasetNameNew());
            // Run the parameterised new method
            Console.WriteLine(checkDatasetNameParameterised(MatchLevelWindow.lsbSelectDataset.Items, txtDatasetName.Text));
​
            // Set the test values to include null
            Program.txtDatasetName = new TextBox(null);
            Program.MatchLevelWindow = new Window(
                new List<string>() {
                    "DatasetA",
                    "DatasetB",
                    "MyDataset",
                    null
                }
            );
            // Run the original method
            try { Console.WriteLine(checkDatasetName()); }
            catch { Console.WriteLine("Error!"); }
            // Run the new method
            Console.WriteLine(checkDatasetNameNew());
            // Run the parameterised new method
            Console.WriteLine(checkDatasetNameParameterised(MatchLevelWindow.lsbSelectDataset.Items, txtDatasetName.Text));
        }
​
        // The old method (copied directly from BitBucket)
        private static bool checkDatasetName()
        {
            // Create and set output bools
            bool isDatasetName = false;
            bool isDatasetNameExist = false;
​
            // Adjust the boolean value of matchSetNameCheck depending on whether or not a match set name has been entered
            if (txtDatasetName.Text.Length != 0)
            {
                isDatasetName = true;
            }
​
            // Loop through every dataset in the match level window and check if the textbox text matches one of them (case insensitive)
            foreach (string datasetName in MatchLevelWindow.lsbSelectDataset.Items)
            {
                if (datasetName.ToLower() == txtDatasetName.Text.ToLower())
                {
                    isDatasetNameExist = true;
                    break;
                }
            }
​
            return isDatasetName && !isDatasetNameExist;
        }
​
        // The new method
        // What has improved?
        // - We no longer create new boolean variables each time the method is called
        //   (isDatasetName and isDatasetNameExist). Instead we directly return the boolean result
        //   of what we wish to check.
        // - Instead of checking for the length of the text we now call the in-built static String
        //   method IsNUllOrEmpty(). The advantage of this is that we can now pass null values
        //   safely without the program throwing an error.
        // - We've simplied the the foreach loop into a LINQ query (which applies ToLower() to each
        //   item in the collection) and call the Contains() method to search for the given string,
        //   which allows for null values in both the collection and the string
        // - Conditional-OR operator will return true if the first statement is true, without
        //   running the (more expensive; algorithm is O(n)) Contains() method. If false it will
        //   then continue to run the second statement.
        // - Using a nice application of De Morgan's law, we have simplied 4* operations
        //   (evaluation of first statement, evaluation of second statement, inversion of value of
        //   second statement and the conjunction of the values of both statements) to 3
        //   (evaluation of first statement, evaluation of second statement, disjunction of the
        //   values of both statements). This is, of course, ignoring the Conditional-OR which
        //   means we're sometimes only performing 2 operations.
        //   * This ia bit of a simplification... but, again is fine for our purposes. Modern
        //     compilers (especially C#'s Roslyn) will probably optimise this out anyway, but it's
        //     very well worth knowing about anyway! You may not even be working with a powerful
        //     compiler, and will have to implement many optimisations on your own. Even the best
        //     compilers will not optimise 90% of your code, given you decide to write it very
        //     poorly. So understanding basic optimisations like this really helps for any kind of
        //     optimisation. Not to mention, it's far more readable than the alternate!
        private static bool checkDatasetNameNew()
        {
            return !(
                String.IsNullOrEmpty(txtDatasetName.Text)
                || MatchLevelWindow.lsbSelectDataset.Items
                    .Select(x => x.ToLower())
                    .Contains(txtDatasetName.Text.ToLower())
            );
        }
​
        // The new parameterised method
        // What has improved?
        // - All improvements in checkDatasetNameNew()
        // - We can now generically apply this method to any input collection and string, rather
        //   than hardcoding them in (MatchLevelWindow.lsbSelectDataset.Items,
        //   txtDatasetName.Text).
        // - The method is far more readable thanks to the shorter parameter names.
        // - If we have to manipulate the collection and/or text multiple times in the method (we
        //   don't), we can simply use the reference to the original collection, rather than have
        //   the code traverse the object and its properties each time (again, this can be
        //   optimised without the parameterisation and compilers may optimise this out anyway, but
        //   is a lot easier this way).*
        //   * Disclaimer: this may not be how the referencing in C# is implemented and might be a
        //     false point, but is worth thinking about as an abstract point regardless.
        private static bool checkDatasetNameParameterised(ICollection<string> items, string text)
        {
            return !(
                String.IsNullOrEmpty(text)
                || items.Select(x => x.ToLower()).Contains(text.ToLower())
            );
        }
    }
​
    // Don't worry about the below. It's just to get the above to work without having to use the entire
    // WPF library and making loads of objects.
​
    public class Window
    {
        private ListBox _listBox;
​
        public Window(IList<string> items)
        {
            _listBox = new ListBox(items);
        }
​
        public ListBox lsbSelectDataset
        {
            get { return _listBox; }
        }
    }
​
    public class ListBox
    {
        private IList<string> _items;
​
        public ListBox(IList<string> items)
        {
            _items = items;
        }
​
        public IList<string> Items
        {
            get { return _items; }
        }
    }
​
    public class TextBox
    {
        private string _text;
​
        public TextBox(string text)
        {
            _text = text;
        }
​
        public string Text
        {
            get { return _text; }
        }
    }
}
​

View IL Code