Question

我有两个类，每个类都做同样的事情，但只有不同之处在于它们在代码中的某些函数中使用不同的逻辑。让我们说：

class A
{
    //has same fields, and method
    void GetDataTable()
    {
         //logic here changes up to table of the database and for some fields.
    }
}

class B
{
    //has same fields, and method
    void GetDataTable()
    {
         //logic here changes up to table of the database and for some fields.
    }
}

在一天结束时，我会添加另一个具有不同逻辑的行为类和GetDataTable方法。我需要采用什么样的设计模式或OO技术才能获得更高质量的代码。

Answer 1

您可能正在寻找Strategy Pattern。

使用每个＆＃34;逻辑＆＃34;的方法定义一个接口。班必须实施。每个＆＃34;逻辑＆＃34; class将实现此接口并在实现的方法中执行其逻辑。

interface IGetDataTable
{
    void GetDataTable();
}

class A : IGetDataTable
{
    public void GetDataTable() { /* Do logic here for class A */ }
}

class B : IGetDataTable
{
    public void GetDataTable() { /* Do logic here for class B */ }
}

然后根据需要选择适当的类（实现IGetDataTable）。

Answer 2

本身没有模式，只是继承。

我使用了抽象类而不是接口，因为你提到了常见的方法。

public abstract class MyBaseClass
{
    // TODO: Common methods here.

    // Inheriting classes must implement this.
    public abstract void GetDataTable();
}

public class A : MyBaseClass
{
    public void GetDataTable()
    {
        // Specific implementation here.
    }
}

public class B : MyBaseClass
{
    public void GetDataTable()
    {
        // Specific implementation here.
    }
}

如果您有使用这些类的东西 - 但只有GetDataTable方法，那么拥有一个接口将是一个好习惯。例如IGetDataTable。

如果没有，则没有必要，抽象类是接口。

public interface IGetDataTable
{
    void GetDataTable();
}

public abstract class MyBaseClass : IGetDataTable
{
    // TODO: Common methods here.

    // Inheriting classes must implement this.
    public abstract void GetDataTable();
}

public class A : MyBaseClass
{
    public void GetDataTable()
    {
        // Specific implementation here.
    }
}

public class B : MyBaseClass
{
    public void GetDataTable()
    {
        // Specific implementation here.
    }
}

Answer 3

您可以使用Strategy Pattern，或者只为这两个类制作共同的抽象祖先。

Answer 4

由于Styxxy建议我使用这样的策略模式：

重构代码所以结果是：

- 更灵活。
- 运行时改变行为
- 没有代码重复

class Program
{
    static void Main(string[] args)
    {
        Apply a = new Apply(); //I will create if I dont need any logic but be able to get AB's behavior, I will call that class NoApply
        Helper(a);

    }
    static void Helper(AB myobj)
    {
        myobj.CanGetDataTable();
    }
}

abstract class AB
{
    IGetDataTable gtb;

    public virtual void LogicSetter(IGetDataTable dt)
    {
        gtb = dt;
    }

    public void CanGetDataTable()
    {
        this.gtb.GetDataTable();
    }
    public void DoSameThingBothAB()
    {
        Console.WriteLine("do same things");
    }
}

class Apply:AB
{
    public Apply()
    {
        base.LogicSetter(new LogicForA());
    }
}

public interface IGetDataTable
{
    void GetDataTable();
}

public class LogicForA:IGetDataTable
{
    public void GetDataTable()
    {
        Console.WriteLine("logic for A");
    }
}

public class LogicForB:IGetDataTable
{
    public void GetDataTable()
    {
        Console.WriteLine("logic for B");
    }
}

public class LogicforFutured:IGetDataTable
{
    public void GetDataTable()
    {
        Console.WriteLine("logic for object created in 2019");
    }
}

我有哪种设计模式

4 个答案: