Поправить схему классов графа

namespace GraphVisualizator.GraphClasses
{
    //NOTE: There are no some argument checks here.
    public class AGraph<TVertex, TVertexValues, TEdge, TEdgeValues>
        where TVertex : Vertex
        where TVertexValues : VertexValues
        where TEdge : Edge
        where TEdgeValues : EdgeValues
    {
        SortedDictionary<string, TVertex> keyVertexDic;
        SortedDictionary<string, TEdge> keyEdgeDic;
        IGraphFactory _factory;
 
        public AGraph(IGraphFactory factory)
        {
            keyVertexDic = new SortedDictionary<string, TVertex>();
            keyEdgeDic = new SortedDictionary<string, TEdge>();
            _factory = factory;
        }
 
        public TVertexValues[] GetAllTVertexValues()
        {
            var resArray = new TVertexValues[keyVertexDic.Count];
            int curResPairIndex = 0;
            foreach (var curTVertex in keyVertexDic.Values)
            {
                resArray[curResPairIndex] = (TVertexValues)_factory.CreateVertexValues(curTVertex);
                curResPairIndex++;
            }
            return resArray;
        }
        public TEdgeValues[] GetAllTEdgeValues()
        {
            var resArray = new TEdgeValues[keyEdgeDic.Count];
            int curResPairIndex = 0;
            foreach (var curTEdge in keyEdgeDic.Values)
            {
                resArray[curResPairIndex] = (TEdgeValues)_factory.CreateEdgeValues(curTEdge);
                curResPairIndex++;
            }
            return resArray;
        }
 
        public TEdgeValues GetTEdgeValues(string key)
        {
            var TEdge = keyEdgeDic[key];
            var values = (TEdgeValues)TEdge.GetValues();
            return values;
        }
        public TVertexValues GetTVertexValues(string key)
        {
            var TVertex = keyVertexDic[key];
            var values = (TVertexValues)TVertex.GetValues();
            return values;
        }
 
        public string[] GetTEdgeKeys()
        {
            var resKeys = new string[keyEdgeDic.Count];
            keyEdgeDic.Keys.CopyTo(resKeys, 0);
            return resKeys;
        }
        public string[] GetTVertexKeys()
        {
            var resKeys = new string[keyVertexDic.Count];
            keyVertexDic.Keys.CopyTo(resKeys, 0);
            return resKeys;
        }
 
        public void CreateTVertex(TVertexValues values)
        {
            if (values.Key == String.Empty)
            {
                throw new ArgumentException("Ключ не может быть пустой строкой.");
            }
            if (keyVertexDic.ContainsKey(values.Key))
            {
                throw new ArgumentException("Вершина с таким ключом уже имеется в графе");
            }
 
            var addingTVertex = (TVertex)_factory.CreateVertex(values.Key, values.Options);
            keyVertexDic.Add(values.Key, addingTVertex);
        }
        public void RemoveTVertex(string key)
        {
            if (!keyVertexDic.ContainsKey(key))
            {
                throw new ArgumentException("Вершина с таким ключом отсутствует в графе");
            }
            else
            {
                var TVertexToRemove = keyVertexDic[key];
                var TEdgeByStartTVertex = FindTEdgeByStartTVertex(TVertexToRemove);
                var TEdgeByEndTVertex = FindTEdgeByEndTVertex(TVertexToRemove);
                if (TEdgeByStartTVertex != null)
                {
                    throw new ArgumentException(String.Format("Вершина с таким ключом является начальной для дуги с ключом: {0}", TEdgeByStartTVertex.Key));
                }
                else if (TEdgeByEndTVertex != null)
                {
                    throw new ArgumentException(String.Format("Вершина с таким ключом является конечной для дуги с ключом: {0}", TEdgeByEndTVertex.Key));
                }
                else
                {
                    keyVertexDic.Remove(key);
                }
            }
        }
 
        public void Connect(TEdgeValues values)
        {
            if (values.Key == String.Empty)
            {
                throw new ArgumentException("Ключ не может быть пустой строкой.");
            }
            if (!keyEdgeDic.ContainsKey(values.Key))
            {
                TVertex startVertex = keyVertexDic[values.StartVertexKey];
                TVertex endVertex = keyVertexDic[values.EndVertexKey];
                if (startVertex == null)
                {
                    throw new ArgumentException("Вершина с таким ключом отсутствует в графе");
                }
                if (endVertex == null)
                {
                    throw new ArgumentException("Вершина с таким ключом отсутствует в графе");
                }
 
                var newTEdge = (TEdge)_factory.CreateEdge(values.Key, (TVertex)startVertex, (TVertex)endVertex, values.Options);
 
                keyEdgeDic.Add(values.Key, newTEdge);
            }
            else
            {
                throw new ArgumentException("Ребро с таким ключом уже имеется в графе");
            }
        }
        public void Disconnect(string TEdgeKey)
        {
            if (!keyEdgeDic.ContainsKey(TEdgeKey))
            {
                throw new ArgumentException("Ребро с таким ключом отсутствует в графе");
            }
            else
            {
                keyEdgeDic.Remove(TEdgeKey);
            }
        }
 
        private TEdge FindTEdgeByStartTVertex(TVertex startTVertex)
        {
            TEdge foundTEdge = null;
            foreach (var curTEdge in keyEdgeDic.Values)
            {
                if (curTEdge.StartVertex == startTVertex)
                {
                    foundTEdge = curTEdge;
                    break;
                }
            }
            return foundTEdge;
        }
        private TEdge FindTEdgeByEndTVertex(TVertex endTVertex)
        {
            TEdge foundTEdge = null;
            foreach (var curTEdge in keyEdgeDic.Values)
            {
                if (curTEdge.EndVertex == endTVertex)
                {
                    foundTEdge = curTEdge;
                    break;
                }
            }
            return foundTEdge;
        }
    }
}

    public class Edge : KeyClass
    {
        public Edge(string key, Vertex startVertex, Vertex endVertex, EdgeOptions options)
            : base(key)
        {
            EndVertex = endVertex;
            StartVertex = startVertex;
            Options = options;
        }
 
        public EdgeOptions Options { get; set; }
        public Vertex EndVertex { get; set; }
        public Vertex StartVertex { get; set; }
 
        public EdgeValues GetValues()
        {
            var values = new EdgeValues(this);
            return values;
        }
    }

    public class GraphicalEdge : Edge
    {
        public GraphicalEdge(string key, Vertex startVertex, Vertex endVertex, GraphicalEdgeOptions options)
            : base(key, startVertex, endVertex, options)
        {
        }
 
        public new GraphicalEdgeOptions Options { get; set; }
    }

    public class EdgeOptions
    {
        public EdgeOptions(decimal cost, EdgeDirection direction)
        {
            Cost = cost;
            Direction = direction;
        }
 
        public decimal Cost { get; set; }
        public EdgeDirection Direction { get; set; }
    }

        public GraphicalEdgeOptions(decimal cost, EdgeDirection direction, EdgeShape shape)
            : base(cost, direction)
        {
            Shape = shape;
        }
        
        public EdgeShape Shape { get; set; }
    }

var dict = new Dictionary<typeof(TVertex), AGraph> { {TVertex1, new AGraph1()}, {TVertex2, new AGraph2()}}

public static AGraph Get<T>() where T : TVertex
{
   switch typeof(T)
   {
      case TVertex1 : return new TVertex1();
      case TVertex1 : return new TVertex2();
      default: throw new ArgumentException();
   }
}