在C#泛型Graph类中如何基于Edge类型实现代码分支？

嘿，我懂你现在的需求——想在泛型Graph<dataType, edgeType>里根据边是有向还是无向执行不同逻辑对吧？你的思路方向是对的，但C#里不能直接像你写的那样比较类型，这里有几个可行的实现方案，咱们一步步说：

1. 运行时类型检查（最直接的临时方案） #

如果你只是想快速实现分支逻辑，可以用C#的类型匹配语法（is关键字）或者typeof来判断类型：

针对边实例的检查 #

如果你的逻辑是基于具体的边对象，可以这样写：

public void ProcessEdge(edgeType edge)
{
    if (edge is DirectedEdge<dataType> directedEdge)
    {
        // 这里可以直接使用directedEdge变量，处理有向边逻辑
        Console.WriteLine($"处理有向边：{directedEdge.Source} -> {directedEdge.Target}");
    }
    else if (edge is UndirectedEdge<dataType> undirectedEdge)
    {
        // 处理无向边逻辑，比如双向操作
        Console.WriteLine($"处理无向边：{undirectedEdge.Source} <-> {undirectedEdge.Target}");
    }
    else
    {
        throw new ArgumentException($"不支持的边类型：{typeof(edgeType).Name}");
    }
}

针对泛型参数类型的检查 #

如果你需要直接检查edgeType这个泛型参数的类型（而不是实例），可以用typeof比较：

public void InitializeGraph()
{
    if (typeof(edgeType) == typeof(DirectedEdge<dataType>))
    {
        // 初始化有向图的逻辑，比如设置邻接表的单向存储
    }
    else if (typeof(edgeType) == typeof(UndirectedEdge<dataType>))
    {
        // 初始化无向图的逻辑，比如预留双向存储的空间
    }
    else
    {
        throw new NotSupportedException($"不支持的边类型：{typeof(edgeType).Name}");
    }
}

注意：如果是开放泛型（比如DirectedEdge<>而不是DirectedEdge<string>），需要用typeof(edgeType).GetGenericTypeDefinition() == typeof(DirectedEdge<>)来判断。

2. 泛型约束 + 重载方法（编译时类型安全） #

如果你想把逻辑拆分得更清晰，同时让编译器帮你做类型检查，可以用泛型约束配合重载方法：

public class Graph<TData, TEdge>
{
    // 针对有向边的重载
    public void AddEdge<TDirected>(TDirected edge) 
        where TDirected : DirectedEdge<TData>
    {
        // 有向边专属逻辑：只添加单向关联
        _adjacencyList[edge.Source].Add(edge.Target);
    }

    // 针对无向边的重载
    public void AddEdge<TUndirected>(TUndirected edge) 
        where TUndirected : UndirectedEdge<TData>
    {
        // 无向边专属逻辑：添加双向关联
        _adjacencyList[edge.Source].Add(edge.Target);
        _adjacencyList[edge.Target].Add(edge.Source);
    }

    private Dictionary<Node<TData>, List<Node<TData>>> _adjacencyList = new();
}

调用的时候，编译器会根据你传入的边类型自动匹配对应的方法，完全不需要运行时判断，类型安全性更高。

3. 多态设计（最符合面向对象的推荐方案） #

上面两种方法都需要在Graph类里做分支判断，不符合开闭原则（以后加新的边类型还要改Graph的代码）。更好的方式是把边的行为封装到边类自己里面，用多态来实现：

首先定义一个边的接口，让所有边类型实现这个接口：

public interface IEdge<T>
{
    Node<T> Source { get; }
    Node<T> Target { get; }
    // 定义边添加到图的行为
    void AddToGraph(Graph<T, IEdge<T>> graph);
}

然后让有向边和无向边分别实现这个接口：

public class DirectedEdge<T> : IEdge<T>
{
    public Node<T> Source { get; }
    public Node<T> Target { get; }

    public DirectedEdge(Node<T> source, Node<T> target)
    {
        Source = source;
        Target = target;
    }

    public void AddToGraph(Graph<T, IEdge<T>> graph)
    {
        // 有向边自己定义添加逻辑：单向添加
        graph.AdjacencyList[Source].Add(Target);
    }
}

public class UndirectedEdge<T> : IEdge<T>
{
    public Node<T> Source { get; }
    public Node<T> Target { get; }

    public UndirectedEdge(Node<T> source, Node<T> target)
    {
        Source = source;
        Target = target;
    }

    public void AddToGraph(Graph<T, IEdge<T>> graph)
    {
        // 无向边自己定义添加逻辑：双向添加
        graph.AdjacencyList[Source].Add(Target);
        graph.AdjacencyList[Target].Add(Source);
    }
}

最后Graph类只需要调用统一的方法，不用做任何分支：

public class Graph<TData, TEdge> where TEdge : IEdge<TData>
{
    public Dictionary<Node<TData>, List<Node<TData>>> AdjacencyList { get; } = new();

    public void AddEdge(TEdge edge)
    {
        // 直接让边自己处理添加逻辑，Graph完全不用关心是有向还是无向
        edge.AddToGraph(this);
    }
}

这种方式的好处是：以后如果要加新的边类型（比如带权重的边），只需要新增一个实现IEdge<T>的类，完全不用修改Graph的代码，扩展性极强。

内容的提问来源于stack exchange，提问作者LHOS