C#中如何让方法接收不同命名空间的同名同结构类作为参数

这个问题我太熟了！两个类长得一模一样但分属不同命名空间，直接用泛型确实会踩坑——因为C#是强类型语言，编译器可不管它们结构像不像，只认类型本身。咱们一步步来解决：

这是最符合面向对象设计的做法，把两个类的公共成员抽成接口，让它们都实现这个接口，之后泛型就有了明确的约束，编译器就能识别类的成员了。

首先定义统一的接口：

public interface ICommonA
{
    int a { get; set; }
    double b { get; set; }
    void func();
}

然后让两个命名空间的类分别实现这个接口：

// xyz命名空间的类
namespace xyz
{
    public class A : ICommonA
    {
        public int a { get; set; }
        public double b { get; set; }
        public void func() 
        { 
            // 原有业务逻辑
        }
    }
}

// 另一个命名空间的类（比如abc）
namespace abc
{
    public class A : ICommonA
    {
        public int a { get; set; }
        public double b { get; set; }
        public void func() 
        { 
            // 原有业务逻辑
        }
    }
}

最后修改泛型方法，加上接口约束：

void operation<T>(T a) where T : ICommonA
{
    a.func(); // 现在编译器明确知道T实现了ICommonA，能正常识别func()
    // 其他操作，比如访问a.a、a.b也都没问题
}

这样不管是xyz.A还是abc.A，都能直接传入这个方法复用逻辑了。

如果这两个类是你没法修改的外部资源（比如第三方NuGet包、遗留代码），可以用下面两种方式：

方式A：使用动态类型（dynamic） #

这种方式最简单，但会失去编译时类型检查，运行时如果传入的类型没有对应成员会报错：

void operation(dynamic a)
{
    a.func(); // 编译器不做检查，运行时才解析成员
    // 其他操作逻辑
}

优点是不用改任何原有代码，缺点是没有编译安全保障，且性能略低于强类型调用。

方式B：适配器模式 #

创建适配器类，把无法修改的类包装成符合统一接口的类型，既保留编译安全，又能复用原有逻辑：
先复用前面定义的ICommonA接口，然后为目标类创建适配器：

// 适配abc.A的适配器类
public class AbcAAdapter : ICommonA
{
    private readonly abc.A _innerA;

    public AbcAAdapter(abc.A innerA)
    {
        _innerA = innerA;
    }

    public int a 
    { 
        get => _innerA.a; 
        set => _innerA.a = value; 
    }

    public double b 
    { 
        get => _innerA.b; 
        set => _innerA.b = value; 
    }

    public void func()
    {
        _innerA.func();
    }
}

使用时把abc.A包装成适配器传入方法：

var abcAInstance = new abc.A();
operation(new AbcAAdapter(abcAInstance));

你写的void operation<T>(T a)里的T是无约束的，编译器完全不知道T是什么类型——它可能是int、string，也可能是你的类，自然无法确认T有func()方法。必须给T加上约束，告诉编译器“这个T一定包含这些成员”，接口约束就是最常用的方式。

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