BFS и DFS через матрицу смежности c#

Как реализовать BFS(поиск в ширину) и DFS(поиск в глубину) через матрицу смежности, если вершины в графе указаны в формате string? Имеющийся код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace adj
{
    class Edge
    {
        public Vertex From { get; set; }   //От куда 
        public Vertex To { get; set; }     //Куда
        public int Weight { get; set; }
 
        public Edge()
        {
            From = null;
            To = null;
            Weight = 0;
        }
 
        public Edge(Vertex from, Vertex to, int weight = 1)
        {
            From = from;
            To = to;
            Weight = weight;
        }
 
        public override string ToString()
        {
            return $"({From}; {To}; {Weight})";
        }
    }
    class Vertex
    {
        public string Name { get; set; }
        public bool visited { get; set; }
        //public bool visit;        //посещение вершины
        public List<Edge> adjLEdges;   //набор смежных ребер (т.е. ребра, котрые выходят из данной вершины)
        Vertex()
        {
            Name = "No name";
            adjLEdges = new List<Edge>();
        }
 
        public Vertex(string name)
        {
            Name = name;
            adjLEdges = new List<Edge>();
        }
 
        public int CountEdgesVertex { get { return adjLEdges.Count; } }     //Кол-во ребер, идущих от вершины
 
        public override string ToString()
        {
            return string.Format("Name: ({0})", Name);
        }
    }
    class Graph
    {
        public List<Vertex> Vertexes = new List<Vertex>();
        public List<Edge> Edges = new List<Edge>();
        public int VertexCount { get { return Vertexes.Count; } }
        public int EdgeCount { get { return Edges.Count; } }
 
        public void AddVertex(Vertex vertex)
        {
            Vertexes.Add(vertex);
        }
 
        public bool AddEdge(Vertex from, Vertex to)
        {
            Edge edge = new Edge(from, to);
            if (Edges.Contains(edge)) return false;
            Edges.Add(edge);
            from.adjLEdges.Add(edge);
            return true;
        }
        public int?[,] CreateAdjMatrix() // получение матрицы смежности
        {
            int?[,] adj = new int?[Vertexes.Count, Vertexes.Count];
 
            for (int i = 0; i < Vertexes.Count; i++)
            {
                Vertex n1 = Vertexes[i];
 
                for (int j = 0; j < Vertexes.Count; j++)
                {
                    Vertex n2 = Vertexes[j];
 
                    var arc = n1.adjLEdges.FirstOrDefault(a => a.To == n2);
 
                    if (arc != null)
                    {
                        adj[i, j] = arc.Weight;
                    }
                }
            }
            return adj;
        }
        public Vertex FindVertex(Vertex vertexName) //Поиск вершины
        {
            foreach (var v in Vertexes)
            {
                if (v.Name.Equals(vertexName))
                {
                    return v;
                }
            }
            return null;
        }
        class Program
        {
            static void Main(string[] args)
            {
                Graph gr = new Graph();
                Vertex v1 = new Vertex("A");
                Vertex v2 = new Vertex("B");
                Vertex v3 = new Vertex("C");
                Vertex v4 = new Vertex("D");
                Vertex v5 = new Vertex("E");
                Vertex v6 = new Vertex("F");
 
                gr.AddVertex(v1);
                gr.AddVertex(v2);
                gr.AddVertex(v3);
                gr.AddVertex(v4);
                gr.AddVertex(v5);
                gr.AddVertex(v6);
 
                gr.AddEdge(v1, v2);
                gr.AddEdge(v2, v1);
                gr.AddEdge(v2, v3);
                gr.AddEdge(v3, v2);
                gr.AddEdge(v1, v3);
                gr.AddEdge(v3, v1);
                gr.AddEdge(v4, v5);
                gr.AddEdge(v5, v4);
                int?[,] adj = gr.CreateAdjMatrix(); 
                PrintMatrix(ref adj, gr.Vertexes.Count);
            }
            private static void PrintMatrix(ref int?[,] matrix, int Count)
            {
                Console.Write("       ");
                for (int i = 0; i < Count; i++)
                {
                    Console.Write("{0}  ", (char)('A' + i));
                }
 
                Console.WriteLine();
 
                for (int i = 0; i < Count; i++)
                {
                    Console.Write("{0} | [ ", (char)('A' + i));
 
                    for (int j = 0; j < Count; j++)
                    {
                        if (matrix[i, j] == null)
                        {
                            Console.Write(" 0,");
                        }
                        else
                        {
                            Console.Write(" {0},", matrix[i, j]);
                        }
 
                    }
                    Console.Write(" ]\r\n");
                }
                Console.Write("\r\n");
            }
 
        }
    }
}