Алгоритм Дейкстры и нахождения кратчайших путей

enum NodeStatuses : int { Empty, Taxi, Client };
    /// <summary>
    /// Представляє об'єкти графа - вузли
    /// Кожен вузол має наступні поля:
    ///     1. Стан - описує стан цього вузла(зупинки) (вільна зупинка, місце стоянки таксі, локація клієнта)
    ///     2. Номер - ідентифікатор вузла |readonly
    ///     3. Координати розміщення вузла на формі |readonly
    /// </summary>
    public class Node
    {
        //Поля
        public int Status { get; set; }
        public readonly int Number;
        public readonly Point placement;
        //Конструктори
        public Node(int number, Point point)
        {
            Status = (int)NodeStatuses.Empty;
            placement = point;
            Number = number;
        }
        public Node(int number, int left, int top) : this(number, new Point(left, top)) { }
 
        public static bool operator ==(Node A, Node B)
        {
            try
            {
                return (A.Number == B.Number && A.placement == B.placement);
            }
            catch(NullReferenceException)
            { return false; }
            catch
            { throw new Exception(); }
        }
        public static bool operator !=(Node A, Node B) => !(A == B);
 
        public override bool Equals(object obj)
        {
            var node = obj as Node;
            return node != null &&
                   Status == node.Status &&
                   Number == node.Number &&
                   EqualityComparer<Point>.Default.Equals(placement, node.placement);
        }
    }
}

  public class Edge
    {
        //Статичні поля
        /// <summary>
        /// Нескінченність - для алгоритму Дейкстри
        /// </summary>
        public static double Infinity = double.PositiveInfinity;
        /// <summary>
        /// Ребро з довжиною нескінченність(уособлює відсутість ребра між точками) - для алгоритму Дейкстри
        /// </summary>
        public static Edge notExistingEdge = new Edge(-1, -1, -1, -1);
        /// <summary>
        /// Ребро з довжиною нуль(уособлює ребро яке звязує одну ту же точку) - для алгоритму Дейкстри
        /// </summary>
        public static Edge nullLengthEdge = new Edge(0, 0, 0, 0);
        //Поля
        public readonly Point Start;
        public readonly Point Final;
        //Властивості
        /// <summary>
        /// Повертає довжину ребра
        /// </summary>
        public double Length
        {
            get
            {
                if (Start == new Point(-1, -1))
                    return Infinity;
                return Math.Sqrt(Math.Pow((Start.X - Final.X), 2) + Math.Pow((Start.Y - Final.Y), 2));
            }
        }
        //Конструктори
        /// <summary>
        /// Конструктор, що створює ребро за заданими координатами
        /// Є перезаванження для підтримки як 4 int так і 2 об'єктів класу Point та Pair
        /// </summary>
        public Edge(Point S, Point F)
        {
            Start = S;
            Final = F;
        }
        public Edge(Pair<int> S, Pair<int> F)
        {
            Start = new Point(S[0], S[1]);
            Final = new Point(F[0], F[1]);
        }
        public Edge(int startX, int startY, int finalX, int finalY)
        {
            Start = new Point(startX, startY);
            Final = new Point(finalX, finalY);
        }
 
        public static bool operator ==(Edge A, Edge B)
        {
            try
            {
                return (A.Start == B.Start && A.Final == B.Final);
            }
            catch (NullReferenceException)
            { return false; }
            catch
            { throw new Exception(); }
        }
        public static bool operator !=(Edge A, Edge B) => !(A == B);
 
        public override bool Equals(object obj)
        {
            var edge = obj as Edge;
            return edge != null &&
                   EqualityComparer<Point>.Default.Equals(Start, edge.Start) &&
                   EqualityComparer<Point>.Default.Equals(Final, edge.Final);
        }
    }

public double[] Dijkstra(Node Alpha)
        {
            //Підготовка
            ////Список відвіданих точок
            ////При чому точка для якої обраховуємо відстані зразу додається у список відвіданих
            List<Node> Visited = new List<Node>(NodeCount);
            Visited.Add(Alpha);
            ////Массив ,що зберігатиме відстані від Alpha до решти вузлів
            double[] D = new double[NodeCount];
 
            for (int i = 0; i < D.Length; i++)
                D[i] = double.PositiveInfinity;
            D[Alpha.Number] = 0;
            ////Масив ,що зберігати найкоротші шляхи
            Node[] AltShortWays = new Node[NodeCount];
 
            ////Постійна мітка
            Node W = Alpha;
            ////
            do
            {
                for (int i = 0; i < NodeCount; i++)
                {
                    if (Visited.Contains(GetNodeByID(i)))
                        continue;
                    Node currentNode = GetNodeByID(i);
                    Edge currentEdge = this[new NodePair(W, currentNode)];//індексатор повертає ребро, що звязує ці вузли
                    double current = currentEdge.Length + D[W.Number];
 
                    if (D[i] > current)
                    {
                        D[i] = current;
                        AltShortWays[i] = currentNode;
                    }
                }
                List<Node> MinList = GetMinList(D, Visited); //повертає мінімальні значення масиву D (на випадок якщо їх багато)
                foreach (var min in MinList)
                {
                    bool Break = false;
                    foreach (var vis in Visited)
                    {
                        if (vis.Number != min.Number)
                        {
                            W = min;
                            Break = true;
                            break;
                        }
                    }
                    if (Break)
                        break;
                }
                Visited.Add(W);
            } while (Visited.Count != NodeCount);
 
            return D;
 
        }