program-p1-dyamicConnection

using System;
using System.Reflection; // Импортираме пространството от имена за работа с рефлексия

namespace p1
{
    // Клас за представяне на програмата
    class Program
    {
        // Метод за стартиране на програмата
        static void Main(string[] args)
        {
            // Зареждаме динамичната библиотека d1.dll от текущата директория
            Assembly assembly = Assembly.LoadFile(Environment.CurrentDirectory + "\\d1.dll");

            // Тестваме функцията за сортиране на масив по метода на мехурчето
            TestBubbleSort(assembly);

            // Тестваме функцията за намиране на факториел от дадено число рекурсивно
            TestFactorial(assembly);

            // Тестваме функциите за работа със стек
            TestStack(assembly);

            // Тестваме функциите за работа с опашка
            TestQueue(assembly);

            // Тестваме функциите за работа със списък
            TestList(assembly);

            // Тестваме функциите за работа с дърво
            TestTree(assembly);

            // Тестваме функциите за работа с речник
            TestDictionary(assembly);
        }

        // Метод за тестване на функцията за сортиране на масив по метода на мехурчето
        static void TestBubbleSort(Assembly assembly)
        {
            Console.WriteLine("Тестване на функцията за сортиране на масив по метода на мехурчето:");

            int[] array = { 5, 3, 7, 1, 9, 4, 2, 6, 8 }; // Създаваме масив с произволни числа

            Console.WriteLine("Масивът преди сортирането:");
            PrintArray(array); // Извеждаме масивът преди сортирането

            // Намираме класа Algorithm в динамичната библиотека
            Type algorithmType = assembly.GetType("d1.Algorithm");

            // Намираме статичния метод BubbleSort в класа Algorithm
            MethodInfo bubbleSortMethod = algorithmType.GetMethod("BubbleSort");

            // Извикваме метода BubbleSort с параметър масивът, който искаме да сортираме
            bubbleSortMethod.Invoke(null, new object[] { array });

            Console.WriteLine("Масивът след сортирането:");
            PrintArray(array); // Извеждаме масивът след сортирането

            Console.WriteLine();
        }

        // Метод за извеждане на елементите на масив
        static void PrintArray(int[] array)
        {
            foreach (int element in array) // Обхождаме всички елементи на масива
            {
                Console.Write(element + " "); // Извеждаме текущия елемент, разделен с интервал
            }
            Console.WriteLine(); // Превъртаме нов ред
        }

        // Метод за тестване на функцията за намиране на факториел от дадено число рекурсивно
        static void TestFactorial(Assembly assembly)
        {
  Console.WriteLine("Тестване на функцията за намиране на факториел от дадено число рекурсивно:");

            int n = 5; // Задаваме произволно число

            Console.WriteLine("Числото е: " + n); // Извеждаме числото

            // Намираме класа Algorithm в динамичната библиотека
            Type algorithmType = assembly.GetType("d1.Algorithm");

            // Намираме статичния метод Factorial в класа Algorithm
            MethodInfo factorialMethod = algorithmType.GetMethod("Factorial");

            // Извикваме метода Factorial с параметър числото, от което искаме да намерим факториела
            int result = (int)factorialMethod.Invoke(null, new object[] { n });

            Console.WriteLine("Факториелът от числото е: " + result); // Извеждаме резултата

            Console.WriteLine();
        }
 // Метод за тестване на функциите за работа със стек
        static void TestStack(Assembly assembly)
        {
            Console.WriteLine("Тестване на функциите за работа със стек:");

            // Намираме класа Stack в динамичната библиотека
            Type stackType = assembly.GetType("d1.Stack`1");

            // Създаваме нов стек с капацитет 10 и тип int
            object stack = Activator.CreateInstance(stackType.MakeGenericType(typeof(int)), new object[] { 10 });

            // Намираме методите Push, Pop, Peek и IsEmpty в класа Stack
            MethodInfo pushMethod = stackType.GetMethod("Push");
            MethodInfo popMethod = stackType.GetMethod("Pop");
            MethodInfo peekMethod = stackType.GetMethod("Peek");
            MethodInfo isEmptyMethod = stackType.GetMethod("IsEmpty");

            Console.WriteLine("Добавяме елементи в стека:");
            for (int i = 1; i <= 5; i++) // Добавяме пет елемента в стека
            {
                Console.WriteLine("Добавяме " + i);
                pushMethod.Invoke(stack, new object[] { i }); // Извикваме метода Push с параметър i
            }

            Console.WriteLine("Взимаме елемента на върха на стека без да го премахваме:");
            Console.WriteLine("Елементът е: " + peekMethod.Invoke(stack, null)); // Извикваме метода Peek без параметри

            Console.WriteLine("Премахваме елементи от стека:");
            while (!(bool)isEmptyMethod.Invoke(stack, null)) // Докато стекът не е празен
            {
                Console.WriteLine("Премахваме " + popMethod.Invoke(stack, null)); // Извикваме метода Pop без параметри и извеждаме резултата
            }

            Console.WriteLine();
        }

        // Метод за тестване на функциите за работа с опашка
        static void TestQueue(Assembly assembly)
        {
            Console.WriteLine("Тестване на функциите за работа с опашка:");

            // Намираме класа Queue в динамичната библиотека
            Type queueType = assembly.GetType("d1.Queue`1");

            // Създаваме нова опашка с капацитет 10 и тип int
            object queue = Activator.CreateInstance(queueType.MakeGenericType(typeof(int)), new object[] { 10 });

            // Намираме методите Enqueue, Dequeue, Peek и IsEmpty в класа Queue
            MethodInfo enqueueMethod = queueType.GetMethod("Enqueue");
            MethodInfo dequeueMethod = queueType.GetMethod("Dequeue");
            MethodInfo peekMethod = queueType.GetMethod("Peek");
            MethodInfo isEmptyMethod = queueType.GetMethod("IsEmpty");

            Console.WriteLine("Добавяме елементи в опашката:");
            for (int i = 1; i <= 5; i++) // Добавяме пет елемента в опашката
            {
                Console.WriteLine("Добавяме " + i);
                enqueueMethod.Invoke(queue, new object[] { i }); // Извикваме метода Enqueue с параметър i
            }

            Console.WriteLine("Взимаме елемента в началото на опашката без да го премахваме:");
            Console.WriteLine("Елементът е: " + peekMethod.Invoke(queue, null)); // Извикваме метода Peek без параметри

            Console.WriteLine("Премахваме елементи от опашката:");
            while (!(bool)isEmptyMethod.Invoke(queue, null)) // Докато опашката не е празна
            {
                Console.WriteLine("Премахваме " + dequeueMethod.Invoke(queue, null)); // Извикваме метода Dequeue без параметри и извеждаме резултата
            }

            Console.WriteLine();
        }

        // Метод за тестване на функциите за работа със списък
        static void TestList(Assembly assembly)
        {
            Console.WriteLine("Тестване на функциите за работа със списък:");

            // Намираме класа List в динамичната библиотека
            Type listType = assembly.GetType("d1.List`1");

            // Създаваме нов списък с тип int
            object list = Activator.CreateInstance(listType.MakeGenericType(typeof(int)));

            // Намираме методите AddFirst, AddLast, RemoveFirst, RemoveLast, GetFirst, GetLast и IsEmpty в класа List
            MethodInfo addFirstMethod = listType.GetMethod("AddFirst");
            MethodInfo addLastMethod = listType.GetMethod("AddLast");
            MethodInfo removeFirstMethod = listType.GetMethod("RemoveFirst");
            MethodInfo removeLastMethod = listType.GetMethod("RemoveLast");
            MethodInfo getFirstMethod = listType.GetMethod("GetFirst");
            MethodInfo getLastMethod = listType.GetMethod("GetLast");
            MethodInfo isEmptyMethod = listType.GetMethod("IsEmpty");

            Console.WriteLine("Добавяме елементи в началото и в края на списъка:");
            for (int i = 1; i <= 5; i++) // Добавяме пет елемента в началото и в края на списъка
            {
                Console.WriteLine("Добавяме " + i + " в началото");
                addFirstMethod.Invoke(list, new object[] { i }); // Извикваме метода AddFirst с параметър i

                Console.WriteLine("Добавяме " + (i + 5) + " в края");
                addLastMethod.Invoke(list, new object[] { i + 5 }); // Извикваме метода AddLast с параметър i + 5
            }

            Console.WriteLine("Взимаме елементите в началото и в края на списъка без да ги премахваме:");
            Console.WriteLine("Елементът в началото е: " + getFirstMethod.Invoke(list, null)); // Извикваме метода GetFirst без параметри
            Console.WriteLine("Елементът в края е: " + getLastMethod.Invoke(list, null)); // Извикваме метода GetLast без параметри

            Console.WriteLine("Премахваме елементи от началото и от края на списъка:");
            while (!(bool)isEmptyMethod.Invoke(list, null)) // Докато списъкът не е празен
            {
                Console.WriteLine("Премахваме " + removeFirstMethod.Invoke(list, null) + " от началото"); // Извикваме метода RemoveFirst без параметри и извеждаме резултата
                if (!(bool)isEmptyMethod.Invoke(list, null)) // Ако списъкът не е празен
                {
                    Console.WriteLine("Премахваме " + removeLastMethod.Invoke(list, null) + " от края"); // Извикваме метода RemoveLast без параметри и извеждаме резултата
                }
            }

            Console.WriteLine();
        }

        // Метод за тестване на функциите за работа с дърво
        static void TestTree(Assembly assembly)
        {
 Console.WriteLine("Тестване на функциите за работа с дърво:");

            // Намираме класа Tree в динамичната библиотека
            Type treeType = assembly.GetType("d1.Tree`1");

            // Създаваме ново дърво с тип int
            object tree = Activator.CreateInstance(treeType.MakeGenericType(typeof(int)));

            // Намираме класа Node в динамичната библиотека
            Type nodeType = assembly.GetType("d1.Node`1");

            // Намираме методите AddRoot, AddChild, RemoveRoot, RemoveChild, GetRoot, GetChild и IsEmpty в класа Tree
            MethodInfo addRootMethod = treeType.GetMethod("AddRoot");
            MethodInfo addChildMethod = treeType.GetMethod("AddChild");
            MethodInfo removeRootMethod = treeType.GetMethod("RemoveRoot");
            MethodInfo removeChildMethod = treeType.GetMethod("RemoveChild");
            MethodInfo getRootMethod = treeType.GetMethod("GetRoot");
            MethodInfo getChildMethod = treeType.GetMethod("GetChild");
            MethodInfo isEmptyMethod = treeType.GetMethod("IsEmpty");

            // Намираме свойството Value в класа Node
            PropertyInfo valueProperty = nodeType.GetProperty("Value");

            Console.WriteLine("Добавяме корен на дървото:");
            Console.WriteLine("Добавяме 1");
            addRootMethod.Invoke(tree, new object[] { 1 }); // Добавяме корен със стойност 1

            Console.WriteLine("Добавяме деца към корена на дървото:");
            Console.WriteLine("Добавяме 2");
            addChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 2 }); // Добавяме дете със стойност 2 към корена

            Console.WriteLine("Добавяме 3");
            addChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 3 }); // Добавяме дете със стойност 3 към корена

            Console.WriteLine("Добавяме 4");
            addChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 4 }); // Добавяме дете със стойност 4 към корена

            Console.WriteLine("Добавяме деца към първото дете на корена:");
            Console.WriteLine("Добавяме 5");
            addChildMethod.Invoke(tree, new object[] { getChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 0 }), 5 }); // Добавяме дете със стойност 5 към първото дете на корена

            Console.WriteLine("Добавяме 6");
            addChildMethod.Invoke(tree, new object[] { getChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 0 }), 6 }); // Добавяме дете със стойност 6 към първото дете на корена

            Console.WriteLine("Взимаме второто дете на първото дете на корена без да го премахваме:");
            Console.WriteLine("Елементът е: " + valueProperty.GetValue(getChildMethod.Invoke(tree, new object[] { getChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 0 }), 1 }))); // Извикваме метода GetChild два пъти и извеждаме стойността на елемента

            Console.WriteLine("Премахваме второто дете на първото дете на корена:");
            Console.WriteLine("Премахваме " + removeChildMethod.Invoke(tree, new object[] { getChildMethod.Invoke(tree, new object[] { getRootMethod.Invoke(tree, null), 0 }), 1 })); // Извикваме метода RemoveChild и извеждаме резултата

            Console.WriteLine("Премахваме корена на дървото:");
            Console.WriteLine("Премахваме " + removeRootMethod.Invoke(tree, null)); // Извикваме метода RemoveRoot и извеждаме резултата

            Console.WriteLine();
        }
    }
}