0

我正在设计一个出现以下扫描的系统。我有一个方法 f1() ，其行为因实现而异。我有一个方法 f2() ，所有实现的行为都是相同的。

我设计如下：

interface I1
{
        //Behaviour will vary across implementations 
        void f1();
        //Same behaviour for all implementations
        void f2();

 }

    abstract class C
    {
        //Implemented in the Base class
        void f2()
        {


        }
    }

    public class C1:C,I1
    {
        //Implemented interface method
        public f1()
        {

        }

    }
    public class C2:C,I1
    {
        //Implemented  interface method
        public f1()
        {

        }

    }

设计是否正确？任何人都可以在这个场景中提出任何合适的设计吗？

4

3 回答 3

3

您应该只使用 f1() 和 f2() 方法创建一个抽象类，如下所示：

abstract class A
{
    public abstract f1();
    protected void f2()
    {
    }
}

class B : A
{
    public override void f1()
    {
    }
}

现在，每当您基于 A 创建一个类时，它们都可以为方法 f1() 指定自己的行为。

于 2013-09-02T11:21:25.553 回答
0

我遵循 OOP 设计原则和策略模式，为您的问题提供良好的解决方案。这些是我遵循的原则： 1. 优先组合而不是继承。2.程序接口而不是实现，

  public interface I1VariedBehavior
{
    void f1(); // Varies for the implementation.
}
public abstract class I1SameBehavior
{

    public void f2()
    {
        Console.WriteLine("f2 same behavior");
    }
}
public class F1Impl1 : I1VariedBehavior
{
    public void f1() // f1 is own implementation 
    {
        Console.WriteLine("F1 own implementation 1");
    }
}
public class F1Impl2 : I1VariedBehavior
{
    public void f1() // f1 is own implementation 
    {
        Console.WriteLine("F1 own implementation 2");
    }
}
public class C1 : I1SameBehavior
{
    I1VariedBehavior strategy;
    public C1(I1VariedBehavior strategy)
    {
        this.strategy = strategy;
    }
    public void f1()
    {
        strategy.f1();
    }        
}

public class Client
{
    public static void Main(String[] args)
    {
        C1 c1 = new C1(new F1Impl1());
        c1.f1();
        c1.f2();

        C1 c2 = new C1(new F1Impl2());
        c2.f1();
        c2.f2();
        Console.Read();
    }
}

输出：

F1 own implementation 1
f2 same behavior
F1 own implementation 2
f2 same behavior

希望有帮助。

于 2013-09-02T12:18:33.217 回答
0

另一种方法是使用策略模式：

public interface IF1Strategy
{
   void f1();
}

public sealed class C : I1
{
    private readonly IF1Strategy _f1Strategy;

    //strategy injected
    public C(IF1Strategy strategy)
    {
       _f1Strategy = strategy;
    }

    void f2()
    {
    }

    void f1()
    {
       //delegated to strategy
       _f1Strategy.f1();
    }
}

注意：仅适用于您的f1策略实施者不需要调用f2.

优点：

  • 您可以注入适当的策略。
  • 您可以自行对策略进行单元测试。
  • 类C可以独立于其他类进行更改，即可以节省您维护类的继承权。请注意我是如何拥有sealed它的。

简而言之，我选择组合而不是继承

于 2013-09-02T11:31:42.957 回答