4

给定以下界面：

public interface IFoo
{
    bool Foo(Person a, Person b);
}

以及上述的以下两个实现：

public class KungFoo : IFoo
{
    public bool Foo(Person a, Person b)
    {
        if (a.IsAmateur || b.IsAmateur) // common logic
          return true;
        return false;
    }
}

public class KongFoo : IFoo
{
    public bool Foo(Person a, Person b)
    {
        if (a.IsAmateur || b.IsAmateur) // common logic
          return false;
        return true;
    }
}

我应该将“通用逻辑”（如代码中的注释）放在哪里，以便它只在一个地方（例如作为 Func）并且不需要重复（如上例）用于多个实现？

请注意，上面的示例非常简单，但现实生活中的“通用逻辑”更加复杂，而 Foo() 方法做了一些有用的事情！

我希望这个问题很清楚（并且尚未在其他地方得到回答 - 我确实进行了搜索），但如果需要，请随时向我询问更多细节。

4

5 回答 5

9

在一个通用的抽象类中：

public interface IFoo
{
    bool Foo(Person a, Person b);
}

public abstract class FooBase : IFoo
{
    public virtual bool Foo(Person a, Person b)
    {
        if (a.IsAmateur || b.IsAmateur) // common logic
          return true;
        return false;
    }
}

public class KungFoo : FooBase
{

}

public class KongFoo : FooBase
{
    public override bool Foo(Person a, Person b)
    {
        // Some other logic if the common logic doesn't work for you here
    }
}
于 2012-09-27T10:38:26.813 回答
1

您可以将基类用于通用方法，但您的通用逻辑（或业务规则）可以使用规范模式相当巧妙地外部化。

那里有很多冗长的示例和白皮书，如果您对这类东西没问题，请通读它们（我觉得它有点过于学术化），但似乎确实有一个很好的介绍：

http://devlicio.us/blogs/jeff_perrin/archive/2006/12/13/the-specification-pattern.aspx

于 2012-09-27T10:49:49.447 回答
0

我不是 ac# 开发人员，但我想说你必须将父类更改为实际类并在其中实现方法，当然如果你想添加其他未实现的方法，你会声明一个抽象类，但是这就是它的样子；

public abstract class IFoo{
   bool Foo(Person a, Person b){
      if (a.IsAmateur || b.IsAmateur) // common logic
         return true;
   }
   public abstract Object otherFooMethod(Object o);
}

然后在您的子课程中，您将像这样使用它：

public class KungFoo : IFoo{
   //Foo already implemented

   public Object otherFooMethod(Object o){
      return o;
   }

}

public class KongFoo : IFoo
{
   public bool Foo(Person a, Person b)
   {
       if (a.IsAmateur || b.IsAmateur) // common logic
         return false;
       return !base.Foo();
   }

   public Object otherFooMethod(Object o){
      return o;
   }
 }
于 2012-09-27T10:53:41.747 回答
0

  • 您可以实现一个由所有适当类继承的类，并将功能作为protected方法提供。

  • 最好您可以实现一个Extension Method，我更喜欢它，因为它不会限制您在某个继承层次结构中使用此逻辑，而是允许您在共享类型或接口的所有类中使用它。

于 2012-09-27T10:40:11.010 回答
0

我会使用这样的抽象基类：

public interface IFoo
{
    bool Foo(Person a, Person b);
}

public class KungFoo : FooImpl
{
    public override bool Foo(Person a, Person b)
    {
        if (this.IsAmateur(a, b))
            return true;
        return false;
    }
}

public class KongFoo : FooImpl
{
    public override bool Foo(Person a, Person b)
    {
        if (this.IsAmateur(a, b))
            return false;
        return true;
    }
}

public abstract class FooImpl : IFoo
{
    public abstract bool Foo(Person a, Person b);

    protected readonly Func<Person, Person, bool> IsAmateur = (a, b) => a.IsAmateur || b.IsAmateur;
}

public class Person
{
    public bool IsAmateur { get; set; }
}
于 2012-09-27T10:43:35.080 回答