0

说，我有ManYouCanHit两个类RichMan和的适配器类TaxiDriver，它们都派生自Person. 我只能访问RichManor的实例TaxiDriver

public interface IManYouCanHit
{
    bool CanIHitThisGuy;
}

public class ManYouCanHit : IManYouCanHit
{
    private enum ManType
    {
        Rich = 0,
        TaxiDriver = 1
    }

    private RichMan richMan;
    private TaxiDriver driver;
    private ManType type;

    public Object ManReference
    {
        get
        {
            if(this.type == ManType.Rich)
            {
                return this.richMan;
            }
            else
            {
                return this.driver;
            }
        }
    }

    public bool CanIHitThisGuy
    {
        get{
            bool canHit = true;
            if(this.type == ManType.RichMan)
            {
                canHit = false;
            }
            return canHit;
        }
    }

    public ManYouCanHit(Person someone)
    {
        if(someone is RichMan)
        {
            this.richMan = someone;
            this.type = ManType.Rich;
        }
        else if(someone is TaxiDriver)
        {
            this.driver = someone;
            this.type = ManType.TaxiDriver;
        }
        else
        {
            // throw an error
        }
    }
}

真实的逻辑比例子复杂，有很多属性和方法可以实现CanIHitThisGuy

可以将两个对象包装到一个适配器中吗？我还能遵循什么其他模式？

这种设计是好是坏？你能给我一些建议吗？

我应该通过暴露原始对象ManReference吗？

4

2 回答 2

1

可以将两个对象包装到一个适配器中吗？

是的，如果您指的是两种类型的对象，则可以。不是你所做的那样。您没有使用 OO 来获得好处。

我还能遵循什么模式？

适配器模式很酷，如果有意义，您应该使用它。但是，如果有更好的东西，只有您现在可以根据您提供的信息来决定。

这种设计是好是坏？

坏的。

我应该通过 ManReference 公开原始对象吗？

只有你知道。如果您担心，请使其不可变。

你能给我一些建议吗？

我会这样重写它：

public interface IManYouCanHit
{
    bool CanIHitThisGuy;
}

public class ManYouCanHit : IManYouCanHit
{
    public ManYouCanHit(Person someone)
    {
        if (!(someone is RichMan) && !(someone is TaxiDriver))
            throw;

        Man = someone;
    }

    public Person Man { get; private set; }

    public bool CanIHitThisGuy
    {
        get
        {
           //this is not good, better to have IsHittable property on Person class
           //so that you can return just Man.IsHittable
            return !(Man is RichMan);
        }
    }
}

你只需要Person在你的类中引用，因为你在构造函数中只接受一个人。如果需要，您仍然可以在构造函数中抛出异常。

于 2013-06-16T11:10:41.357 回答
0

似乎为每个 ManType 创建一个 Person 层次结构和一个子类是合适的。这将允许您摆脱 ManYouCanHit 类中的一些依赖项，这些依赖项表现为条件。

我的意思是代替那个代码：

  public ManYouCanHit(Person someone)
    {
        if(someone is RichMan)
        {
            this.richMan = someone;
            this.type = ManType.Rich;
        }
        else if(someone is TaxiDriver)
        {
            this.driver = someone;
            this.type = ManType.TaxiDriver;
        }
        else
        {
            // throw an error
        }
    }

你会得到这样的：

public void ManYouCanHit(Person someone)
  {
        someone.CanHit();
  }

当添加新类型的人或修改具体人的行为时，这会让您的生活更轻松

于 2013-06-16T10:37:55.230 回答