确定类型等价

Question

是否可以在 C# 中（我使用的是 .Net 4.5，但要求更广泛）来确定泛型类型的两个实现是否在功能上等效？

作为需求示例，假设我有一个IMapper 接口定义为：

public interface IMapper<TTo, TFrom>
{
    TTo MapFrom(TFrom obj);
    TFrom MapFrom(TTo obj);
}

我的理想实现是：

public class MyMapper : IMapper <A, B>
{
    A MapFrom(B obj) {...}
    B MapFrom(A obj) {...}
}

这将是功能等效到：

public class MyEquivalentMapper : IMapper <B, A>
{
    B MapFrom(A obj) {...}
    A MapFrom(B obj) {...}
}

但编译器（正确地）将它们识别为不同的类型。有没有办法告诉编译器将这两种类型视为等效（甚至可以互换）？

我也看过这个：

public interface ISingleMapper<out TTo, in TFrom>
{
    TTo MapFrom(TFrom obj);
}
public class MyAlternateMapper :
    ISingleMapper<A, B>,
    ISingleMapper<B, A>
{
    A MapFrom(B obj) {...}
    B MapFrom(A obj) {...}
}

但我发现我无法正确识别抽象，因此我可以在不创建“中间人”接口的情况下注入（到构造函数等）具体类：

public interface IBidirectionalMapper<TTo, TFrom> :
    ISingleMapper<TTo, TFrom>,
    ISingleMapper<TFrom, TTo>
{
    TTo MapFrom(TFrom obj);
    TFrom MapFrom(TTo obj);
}
public class MyAlternateMapper : IBidirectionalMapper<A, B>
{
    A MapFrom(B obj) {...}
    B MapFrom(A obj) {...}
}

我认为“中间人”方法更“正确”，但我不希望创建多余的类型。此外，它仍然存在交换类型参数会创建两个不同但功能等效类型的问题。

有没有更好的方法来实现我的目标？

Answer 1

真的不清楚你所说的“等价”是什么意思。如果您的意思是两种类型是等效的，因为它们具有相同的成员并且成员具有相同的签名，那么您可以使用反射来确定：

    public class TypeComparer : IEqualityComparer<MemberInfo>
    {
        public bool Equals(MemberInfo x, MemberInfo y)
        {
            return x.ToString() == y.ToString();
        }

        public int GetHashCode(MemberInfo obj)
        {
            return obj.GetHashCode();
        }
    }

    public static bool AreTypesEqual(Type type1, Type type2)
    {
        return type1.GetMembers().
            SequenceEqual(type2.GetMembers(), new TypeComparer());
    }

如果成员的顺序无关紧要：

    public static bool AreTypesEqual2(Type type1, Type type2)
    {
        return type1.GetMembers().OrderBy(e=>e.ToString()).
            SequenceEqual(type2.GetMembers().OrderBy(e=>e.ToString()), new TypeComparer());
    }

Answer 2

没有办法表达IGenericInterface<T,U> 应该被视为等同于IGenericInterface<U,T> 的概念，因为这些接口的方法将被不同地绑定。例如，如果一个类实现了这样的接口

MyClass<T,U> : IGenericInterface<T,U>
{
  public T Convert(U param) { Console.WriteLine("U to T"); }
  public U Convert(T param) { Console.WriteLine("T to U"); }
}

调用哪个函数的选择取决于 T 和 U 的角色。如果执行如下操作：

MyClass2<T,U>
{

  ... inside some method
    T myT;
    U myU;
    IGenericInterface<T,U> myThing = new MyClass<T,U>();
     myT = myThing.Convert(myU);
}

上面的Convert 方法将绑定到输出“U 到 T”的方法，即使在类似MyClass2<Foo,Foo> 这样两种类型相同的情况下也是如此。

Answer 3

您可以有一个映射器来进行两种翻译，但只是让它定向，因为在您的情况下，总是有“我的对象”和“数据库对象”配对。

interface IDbTypeModel<T, TDb>
{
    T FromDb(TDb dbObj);
    TDb ToDb(T obj);
}

Answer 4

鉴于此定义：

public interface IMapper<out TTo, in TFrom>
{
    TTo MapFrom(TFrom obj);
    TFrom MapFrom(TTo obj);
}

IMapper<A, B> 和 IMapper<B, A> 类型实际上是不等价的，因为它们具有不对称的协变/逆变泛型参数。但是，忽略这一点...

您可以尝试以下方法（尽管当 A 和 B 具有相同类型时这可能会出现问题）。

//Represents an oriented one-way mapper
public interface IDirectionalMapper<A, B>
{
    B Map(A obj);
}

//Represents an oriented two-way mapper
public interface IBidirectionalMapper<A, B>
    : IDirectionalMapper<A, B>, IDirectionalMapper<B, A>
{
}

//Represents an unoriented two-way mapper
public interface IUndirectedMapper<A, B>
    : IBidirectionalMapper<A, B>, IBidirectionalMapper<B, A>
{
}

现在，例如，您可以在代码中的某个位置定义IUndirectedMapper<int, string>，然后将其用作IBidirectionalMapper<int, string> 和IBidirectionalMapper<string, int>。

编辑

这些定义为您提供以下三种错误。

IBidirectionalMapper<A,B> 不能同时实现 IDirectionalMapper<A,B> 和 IDirectionalMapper<B,A>，因为它们可能会统一用于某些类型参数替换

看来这种方法行不通，抱歉。