统一通用接口的实现

Question

我正在尝试找到一种方法来对实现通用接口的类型集合进行分组。

这是我的测试设置

using System;
using System.Collections.Generic;


namespace Example
{
    public interface ITypeA { }
    public interface ITypeB { }

    public class DescendantA1 : ITypeA { }
    public class DescendantA2 : ITypeA { }

    public class DescendantB1 : ITypeB { }
    public class DescendantB2 : ITypeB { }

    public interface ITypesMapper<in TTypeA, out TTypeB>
        where TTypeA : ITypeA
        where TTypeB : ITypeB
    {
        TTypeB Map(TTypeA typeA);
    }

    public class FirstMapper : ITypesMapper<DescendantA1, DescendantB1>
    {
        public DescendantB1 Map(DescendantA1 typeA) => throw new NotImplementedException();
    }

    public class SecondMapper : ITypesMapper<DescendantA2, DescendantB2>
    {
        public DescendantB2 Map(DescendantA2 typeA) => throw new NotImplementedException();
    }

    public class Program
    {
        static void Main(string[] args)
        {
            List<ITypesMapper<ITypeA, ITypeB>> types = new List<ITypesMapper<ITypeA, ITypeB>>();
            types.Add(new FirstMapper());
            types.Add(new SecondMapper());
        }
    }
}

上述示例的问题是我无法将FirstMapper 和SecondMapper 添加到集合中，因为我没有捕获它们的接口。 （C# 编译器说它不能将FirstMapper and SecondMapper 转换为ITypesMapper<TTypeA, TTypeB>

我认为通过将我的接口的通用参数限制为继承 ITypeA 和 ITypeB 接口的类型，并使它们成为协/逆变我可以实现这一点。

---

我可以解决此问题的一种方法是将我的 Mapper 类更改为继承 ITypesMapper<ITypeA, ITypeB>，但随后我会在其 Map() 方法中丢失强类型对象，我将不得不投掷。我不想要这个。

另一种方法是定义一个IMapper 接口，该接口将由ITypesMapper<,,> 继承，但是我无法定义Map() 方法来处理泛型参数。

---

我想知道是否有办法创建一组 Mapper 类（如 FirstMapper 和 SecondMapper），每个类都必须有一个可以使用泛型参数的 Map 方法并且有办法将所有这些统一在同一个界面下，然后我可以调用。

我可以更改设计中的所有内容，我只需要：

• 一个界面，我可以将它们全部放在后面（以便它们可以放在一个集合中）。
• 接口应该公开ITypeB Map(ITypeA input)方法
• 具体的映射器实现应该使用具体的类型（所以映射器应该有DescendantB1 Map(DescendantA1 typeA)而不是ITypeB Map(ITypeA input)

Answer 1

这是我认为你能得到的最接近的（这个解决方案也展示了你正在尝试做的问题）-

public interface ITypeA { }
public interface ITypeB { }

public class DescendantA1 : ITypeA { }
public class DescendantA2 : ITypeA { }

public class DescendantB1 : ITypeB { }
public class DescendantB2 : ITypeB { }

public interface ITypeMapper<in TTypeA, out TTypeB>
{
    TTypeB Map(TTypeA typeA);
}

public abstract class TypesMapper<TTypeA, TTypeB>: ITypeMapper<ITypeA, ITypeB>
    where TTypeA : ITypeA
    where TTypeB : ITypeB 
{
    public ITypeB Map(ITypeA typeA) => internalMap(typeA);

    protected abstract TTypeB internalMap(TTypeA a);
}

public class FirstMapper : TypesMapper<DescendantA1, DescendantB1>
{
    protected override DescendantB1 internalMap(DescendantA1 typeA) => throw new NotImplementedException();
}

public class SecondMapper : TypesMapper<DescendantA2, DescendantB2>
{
    protected override DescendantB2 internalMap(DescendantA2 typeA) => throw new NotImplementedException();
}

public static class ProgramTest
{
    static void Main(string[] args)
    {
        List<ITypeMapper<ITypeA, ITypeB>> types = new List<ITypeMapper<ITypeA, ITypeB>>();
        types.Add(new FirstMapper());
        types.Add(new SecondMapper());
    }
}

您在此处遇到的错误在以下行中：

public ITypeB Map(ITypeA typeA) => internalMap(typeA);

告诉我们不能将 ITypeA（基础）转换为 TTypeA（具体）。

现在，我们可以在通用抽象类定义中添加一个类约束，即。

where TTypeA : class, ITypeA

并转换给出错误的行：

public ITypeB Map(ITypeA typeA) => internalMap(typeA as TTypeA);

但是没有什么可以阻止这个列表的使用者使用不是 TTypeA 的参数调用 Map(...)，这就是为什么整个方案一开始就不是类型安全的。尽管如此，如果您正在使用某种检查，并且您真的只会使用正确的具体类型调用 Map 函数，我认为这会让您到达您想去的地方。