Question

EDIT 我已经改写了这个问题，所以它更好地反映了我想要做的事情

我正在尝试创建一组所有继承自1“superclass”或“baseclass”的类。

然而，我正在寻找一种方法来实现每个方法的代码，因为它似乎有很多重复。

这是超级课程：

public abstract class WebObject
{
    string Id { get; set; }
    string Name { get; set; }

    public void Click() { Console.WriteLine("Clicking object"); }
    public string GetAttribute() { return "An attribute"; }
    public void SetAttribute(string attribute, string value)
    {
        //code to set attribute
    }
}

我还创建了几个接口：

interface IReadable
{
    string GetText();
}

interface IWriteable
{
    void SetText(string value);
}

以下是派生类的示例：

public class TextBox: WebObject, IWriteable, IReadable
{


}

当然上面的类包含错误。它没有实现IWriteable或IReadable。

所以我可以这样做：

public class TextBox: WebObject, IWriteable, IReadable
{
    public void SetText(string value)
    {
        //Implemented code
    }

    public string GetText()
    {
        //Implemented code
        return "some value";
    }
}

哪个编译好... 但是这里的问题是SetText和GetText包含很多代码。我不想每次都想要实现该方法时复制它。我只需编写一次代码，并在需要使用该方法时调用它。

我知道我们不能在C＃和Java中进行多重继承。所以我最初的想法只是创建一套静态类，其中包含SetText和GetText的代码：

public static class Setter
{
    public static void SetText(string value)
    {
        //Code to set text
    }
}

public static class Getter
{
    public static string GetText()
    {
        //Code to get text
        return "";
    }
}

然后将TextBox类更改为以下内容：

public class TextBox: WebObject, IWriteable, IReadable
{
    public void SetText(string value)
    {
        Setter.SetText(value);
    }

    public string GetText()
    {
        return Getter.GetText();
    }
}

我无法帮助，但觉得这是一个非常长期的解决方案。它完成了我想要的东西，因为TextBox有vanilla方法加上它实现的2。

但我的问题是，我可以使用更简洁的设计实现相同的目标吗？

脚注

每个对象实际上实现了几种常用方法。采用TextBox，ComboBox和SelectBox，他们都应该能够使用SetText，但只有CombBox和SelectBox应该能够使用Select。

Answer 1

最简洁的方法是在你的基类中实现protected辅助方法，将“大量重复”的问题分解成可以在具体方法实现中组成的小块，像这样：

public abstract class WebObject {
  protected void SetTextImpl() { /* Implementation */ } 
  protected void GetTextImpl() { /* Implementation */ } 
}

然后在派生类中，仅实现适用的接口和适当的方法：

public class TextBox: WebObject, IWriteable, IReadable {
  public void SetText() { SetTextImpl(); }
  public void GetText() { GetTextImpl(); }
}

public class Span: WebObject, IReadable {
  public void GetText() { GetTextImpl(); }
}

如果您知道所有子类都是IReadable，您可以进一步简化：

public abstract class WebObject : IReadable {
  protected void SetTextImpl() { /* Implementation */ } 
  protected void GetTextImpl() { /* Implementation */ } 

  // Implement IReadable -- this could be combined with GetTextImpl() but
  // is implemented separately for consistency.
  public void GetText() { GetTextImpl(); }
}

public class TextBox: WebObject, IWriteable {
  public void SetText() { SetTextImpl(); }
}

public class Span: WebObject, IReadable {
}

Answer 2

如果这两个方法的代码总是相同或大致相同，则可以创建另一个从WebObject继承并实现接口的抽象类（例如：WebObjectReadWrite）。

public abstract class WebObjectReadWrite : WebObject, IReadable, IWritable
{
    // Could be made virtual if some subclasses need to overwrite default implementation.
    public void Read() 
    {
        // Implementation
    }

    // Could be made virtual if some subclasses need to overwrite default implementation.
    public void Write() 
    {
        // Implementation
    }
}

public class TextBox : WebObjectReadWrite
{
}

但是，这可能导致多个继承问题或继承关系没有意义。另一个选择是使用strategy pattern（在路上）将读/写操作委托给可以重用的其他类。

public class TextBox : WebObject, IReadable, IWriteable
{
    private IReadable _readable = new TextReader();
    private IWriteable _writeable = new TextWriter();

    public void Read() 
    {
        _readable.Read();
    }

    public void Write() 
    {
        _writable.Write();
    }
}

public class Span : WebObject, IReadable
{
    // Reused class.
    private IReadable _readable = new TextReader();        

    public void Read() 
    {
        _readable.Read();
    }
}

public class TextReader : IReadable
{
    public void Read()
    {
        // Reusable implementation
    } 
}

这不是策略模式，因为您不允许调用者选择IReadable和IWriteable的实现。但是，它确实允许您重用IReadable和IWriteable类。

如何在实现共享公共方法的接口时删除代码重复

2 个答案: