如何实现这种继承

Question

假设我有一些定义如下：

public interface ISerializable<TSource, TDest>
{
  TDest Serialize();
  TSource Deserialize(TDest dto);
}

现在我希望我的所有对象都实现 ISerializable。所以：

public interface IA<TSource, TDest> : ISerializable<TSource, TDest> {...}
public interface IB<TSource, TDest> : ISerializable<TSource, TDest> {...}
// more interface declaration...

public class A : IA
{
    // implementation here
}
// more class declaration...

关键是，我正在做依赖注入。我希望人们对所有事情都使用 IA，我不希望他们知道 A 类的存在。现在我想为 Serialize/Deserialize 提供一个通用的实现，因为它们大多数都是相同的。

public abstract class Serializable<TSource, TDest> : ISerializable<TSource, TDest>
{
  TDest Serialize() {...}
  TSource Deserialize(TDest dto) {...}
}

问题是，暴露给用户的接口是 IA/IB/... 而 Serialize/Deserialze 的常见实现是在抽象类 C 中。我可以同时实现 IA 和从 C 派生，但最终用户仍然可以'不要使用序列化函数，因为它们是在 C 中声明的。
有没有办法做到这一点？

编辑：
如果我将 IA 更改为 AbstractA，那么 AbstractA 可以从 Serializable 派生，从而解决了这个问题。但是我不能使用接口的某些功能，例如，我可以声明属性，如

public interface IA
{
  string Name { get; }
}
public class A : IA
{
  public string Name { get; set; }
}

这样我可以对最终用户隐藏设置器，而在组装这些类时，我仍然可以不受限制地访问设置器，因为我在内部使用 A 而非 IA。

Answer 1

我仍然不清楚什么让你感到困惑。如果一个类需要具有 ISerialize 方法的 IA 版本，请使用实现 IA 和 ISerializeable 的 IASerializeAware。这有帮助吗？

public interface ISerializable<out T1, T2>
{
    T2 Serialize();
    T1 Deserialize(T2 dto);
}

public interface IA<out T1, T2>
{
    string Name { get; }
}

public interface IASerializeAware<out T1,T2> :  IA<T1, T2>, ISerializable<T1,T2>
{
}

public abstract class ASerializeAwareBase<T1, T2> : Serializable<T1,T2>, IASerializeAware<T1,T2>
{
    public string Name { get; set; }
}

public abstract class Serializable<T1, T2> : ISerializable<T1, T2>
{
    public T2 Serialize()
    {
        throw new NotImplementedException();
    }

    public T1 Deserialize(T2 dto)
    {
        throw new NotImplementedException();
    }
}