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派生，但最终用户仍然可以＆＃39; t使用序列化函数，因为它们在C中声明有没有办法做到这一点？

编辑：
如果我将IA更改为AbstractA，那么AbstractA可以从Serializable派生，有点解决了这个问题。但我不能使用界面的某些功能，例如，我可以声明像

这样的属性

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

这样我可以隐藏最终用户的setter，而在组装这些类时，我仍然可以不受限制地访问setter，因为我在内部使用的不是IA。

Answer 1

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

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();
    }
}

如何实现这种继承

1 个答案: