using System;

using System.Collections.Generic;

​

public static class ExtensionMethods

{

    public static string Join(this IEnumerable<string> source, string delimiter = ";")

    {

        return string.Join(delimiter, source);

    }

}

​

public interface INode<T>

{

    T Value { get; } //removed setter to only allow setting initial value via constructor

​

    INode<T> ParentNode { get; } //type changed to INode<T> and renamed so that it is easier to perform operation on Parent Node

​

    ICollection<INode<T>> ChildNodes { get; } //type changed to ICollection<INode<T>> so that it can hold any list of INode and perform operations easily, setter removed to only use Add/Remove ChildNode functions outside of class

​

    bool HasChildren { get; } //new property to quickly check whether Node has any children, would be helpful in knowing when to perform any list operation on ChildNodes or not

​

    int TotalChildren { get; } //new Property to quickly check total children count and avoid compute it everytime its needed

​

    void SetParentNode(INode<T> child);

    void AddChildNode(INode<T> child); //would help in usage and as we want an INode to only set Value once in constructor

    void RemoveChildNode(INode<T> child); //renamed to show it takes a node for consistency

}

​

public class Node<T> : INode<T>

{

    private T value;

    private INode<T> parentNode;

    private List<INode<T>> childNodes;

    public Node(T value)

    {

        this.value = value;

        childNodes = new List<INode<T>>();

    }

​

    public T Value

    {

        get

        {

            return value;

        }

    }

​

    public INode<T> ParentNode

    {

        get

        {

            return parentNode;

        }

    }

​

    public ICollection<INode<T>> ChildNodes

    {

        get

        {

            return childNodes;

        }

    }

​

    public bool HasChildren

    {

        get

        {

            return childNodes.Count > 0;

        }

    }

​

    public int TotalChildren

    {

        get

        {

            return childNodes.Count;

        }

    }

​

    public void AddChildNode(INode<T> child)

    {

        childNodes.Add(child);

        child.SetParentNode(this);

    }

​

    public void RemoveChildNode(INode<T> child)

    {

        childNodes.Remove(child);

        child.SetParentNode(null);

    }

​

    public void SetParentNode(INode<T> parent)

    {

        parentNode = parent;

    }

}

​

public class Program

{

    public static void Main()

    {

        // TODO - BONUS - demonstrate use of Join extension method

        var cities = new List<string>{"Toronto", "Vancouver", "Calgary"};

        var expected = "Toronto,Vancouver,Calgary";

        var actual = cities.Join(",");

        Console.WriteLine(String.Format("Join extensation method test: expected={0}, actual={1}, passed={2}", expected, actual, expected == actual));

        // TODO - BONUS - demonstrate use of Dispatch method

        TestDispatch1();

        // TODO - BONUS - demonstrate use INode interface

        NodeClassUsageWithCandadianCitiesAndProvinces();

    }

​

    public static int Dispatch(string operation, int a, int b)

    {

        // TODO - answer to question 2

        switch (operation)

        {

            case "add":

                return a + b;

            case "subtract":

                return a - b;

            case "multiply":

                return a * b;

            case "divide":

                return a / b;

            default:

                throw new ArgumentException("invalid argument");

        }

    }

​

    //New Implementation

    public static int Dispatch1(string operation, int a, int b)

    {

        Dictionary<string, Func<int, int, int>> operations = new Dictionary<string, Func<int, int, int>>();

        operations.Add("add", (x, y) => x + y);

        operations.Add("subtract", (x, y) => x - y);

        operations.Add("multiply", (x, y) => x * y);

        operations.Add("divide", (x, y) => x / y);

        Func<int, int, int> func;

        if (operations.TryGetValue(operation, out func))

        {

            return func(a, b);

        }

        else

        {

            throw new ArgumentException("Invalid argument");

        }

    }

​

    public static void TestDispatch1()

    {

        Console.WriteLine("Testing Dispatch1 methods...");

        int expected = 5;

        int actual = Dispatch1("add", 2, 3);

        Console.WriteLine(String.Format("Add Operation test: expected={0}, actual={1}, passed={2}", expected, actual, expected == actual));

        expected = -1;

        actual = Dispatch1("subtract", 2, 3);

        Console.WriteLine(String.Format("Subtract Operation test: expected={0}, actual={1}, passed={2}", expected, actual, expected == actual));

        expected = 6;

        actual = Dispatch1("multiply", 2, 3);

        Console.WriteLine(String.Format("Multiply Operation test: expected={0}, actual={1}, passed={2}", expected, actual, expected == actual));

        expected = 2;

        actual = Dispatch1("divide", 6, 3);

        Console.WriteLine(String.Format("Divide Operation test: expected={0}, actual={1}, passed={2}", expected, actual, expected == actual));

        // Test invalid operation

        try

        {

            Dispatch1("xyz1", 2, 3);

        }

        catch (ArgumentException ex)

        {

            Console.WriteLine(String.Format("Invalid operation test: expected=invalid argument, actual={0}, passed={1}", ex.Message, expected == actual));

        }

​

        Console.WriteLine("-- End of tests ---");

    }

​

    public static void NodeClassUsageWithCandadianCitiesAndProvinces()

    {

        Node<string> canada = new Node<string>("Canada");

        Node<string> ontario = new Node<string>("Ontario");

        Node<string> quebec = new Node<string>("Quebec");

        canada.AddChildNode(ontario);

        canada.AddChildNode(quebec);

        Node<string> toronto = new Node<string>("Toronto");

        Node<string> ottawa = new Node<string>("Ottawa");

        ontario.AddChildNode(toronto);

        ontario.AddChildNode(ottawa);

        Node<string> montreal = new Node<string>("Montreal");

        Node<string> quebecCity = new Node<string>("Quebec City");

        quebec.AddChildNode(montreal);

        quebec.AddChildNode(quebecCity);

        Console.WriteLine(canada.Value); // Output: Canada

        Console.WriteLine(ontario.ParentNode.Value); // Output: Canada

        Console.WriteLine(toronto.ParentNode.Value); // Output: Ontario

        Console.WriteLine(quebecCity.ParentNode.Value); // Output: Quebec

        Console.WriteLine(canada.HasChildren); // Output: True

        Console.WriteLine(canada.TotalChildren); // Output: 2

        Console.WriteLine(ontario.HasChildren); // Output: True

        Console.WriteLine(ontario.TotalChildren); // Output: 2

        Console.WriteLine(toronto.HasChildren); // Output: False

        Console.WriteLine(toronto.TotalChildren); // Output: 0

    }

}