Question

说，我有两个类ManYouCanHit和RichMan的适配器类TaxiDriver，它们都来自Person。我只能访问RichMan或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公开原始对象吗？

Answer 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个引用。如果需要，你仍然可以在构造函数中抛出异常。

Answer 2

似乎适合为每个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();
  }

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

为两个现有类实例设计适配器类的正确方法？

2 个答案: