C#中实现含接口参数的接口方法，如何使用其实现类并保持抽象？

报错原因 #

你提供的代码报错核心原因是方法签名不匹配：

• 接口SearchWorld定义的方法是IEnumerable<Pos> GetNeighbors(Pos pos)
• 但SearchWorldImp中实现的方法参数是Position（推测是笔误，应为PosImp），和接口要求的Pos类型不一致，编译器无法识别这是接口方法的实现，因此提示未实现方法。

可行实现方案 #

完全可以实现你想要的抽象结构，下面提供两种合理的方案：

方案1：调整实现类方法签名匹配接口 #

让SearchWorldImp的GetNeighbors方法参数严格匹配接口的Pos类型，在方法内部将Pos转换为具体的PosImp（需添加类型检查保证安全）：

public interface Pos { }

public interface SearchWorld
{
    IEnumerable<Pos> GetNeighbors(Pos pos);
}

public class PosImp : Pos
{
    public int X { get; set; }
    public int Y { get; set; }
}

public class SearchWorldImp : SearchWorld
{
    public IEnumerable<Pos> GetNeighbors(Pos pos)
    {
        // 类型检查确保安全
        if (pos is not PosImp posImp)
            throw new ArgumentException("参数必须是PosImp类型");
            
        yield return new PosImp { X = posImp.X + 1, Y = posImp.Y };
        // 可添加其他邻居逻辑
    }
}

方案2：使用泛型接口约束类型 #

如果希望实现类明确指定使用的Pos具体类型，同时保留接口的抽象性，可用泛型定义SearchWorld接口：

public interface Pos { }

public interface SearchWorld<TPos> where TPos : Pos
{
    IEnumerable<TPos> GetNeighbors(TPos pos);
}

public class PosImp : Pos
{
    public int X { get; set; }
    public int Y { get; set; }
}

public class SearchWorldImp : SearchWorld<PosImp>
{
    public IEnumerable<PosImp> GetNeighbors(PosImp pos)
    {
        yield return new PosImp { X = pos.X + 1, Y = pos.Y };
        // 其他邻居逻辑
    }
}

这种方式能在编译期确保类型安全，避免运行时类型转换的开销和风险。

基于抽象接口实现深度优先搜索 #

不管用哪种方案，都可以仅依赖Pos和SearchWorld（或泛型版本）接口实现DFS算法，完全不耦合具体实现类：

// 基于非泛型接口的DFS实现
public static class DfsAlgorithm
{
    public static void Search(Pos startPos, SearchWorld world, HashSet<Pos> visited)
    {
        if (visited.Contains(startPos))
            return;
            
        visited.Add(startPos);
        // 处理当前节点（示例为打印坐标，可按需调整）
        if (startPos is PosImp posImp)
            Console.WriteLine($"访问节点：({posImp.X}, {posImp.Y})");
            
        foreach (var neighbor in world.GetNeighbors(startPos))
        {
            Search(neighbor, world, visited);
        }
    }
}

// 使用示例
var start = new PosImp { X = 0, Y = 0 };
var world = new SearchWorldImp();
var visited = new HashSet<Pos>();
DfsAlgorithm.Search(start, world, visited);

如果使用泛型接口，DFS方法也可改为泛型版本，进一步提升类型安全性：

public static class GenericDfsAlgorithm
{
    public static void Search<TPos>(TPos startPos, SearchWorld<TPos> world, HashSet<TPos> visited) where TPos : Pos
    {
        if (visited.Contains(startPos))
            return;
            
        visited.Add(startPos);
        // 处理当前节点，无需类型转换
        if (startPos is PosImp posImp)
            Console.WriteLine($"访问节点：({posImp.X}, {posImp.Y})");
            
        foreach (var neighbor in world.GetNeighbors(startPos))
        {
            Search(neighbor, world, visited);
        }
    }
}

整个DFS算法仅依赖抽象接口，后续替换Pos或SearchWorld的实现类时，算法代码无需修改，完全符合你想要的抽象性要求。

内容的提问来源于stack exchange，提问作者J.Somers