Question

我之前发布过this，但我觉得它过于冗长且无关紧要。我的问题也像this。第二个链接中的一张海报说答案（为什么你不能做下面的代码）是一个设计问题，特别是“继承的坏用法”。所以我想再次与StackOverflow的专家一起检查这个问题，看看这是否真的是“糟糕的继承”问题 - 但更重要的是，如何修复设计。

就像海报一样，我也对Factory方法以及如何应用它感到困惑。似乎工厂方法适用于多个具体类 与抽象基类完全相同的实现，而不添加自己的属性。但是，正如您将在下面看到的那样，我的具体类构建在抽象基类上，添加额外属性。

我们建立的基类：

public abstract class FlatScreenTV
{
     public string Size { get; set; }
     public string ScreenType { get; set; }
}

扩展类示例：

public class PhillipsFlatScreenTV : FlatScreenTV
{
     // Specific to Phillips TVs. Controls the backlight intensity of the LCD screen.
     public double BackLightIntensity { get; set; }
}

public class SamsungFlatScreenTV : FlatScreenTV
{
     // Specific to Samsung TVs. Controls the time until the TV automatically turns off.
     public int AutoShutdownTime { get; set; }
}

假设有更多品牌的平板电视有更多扩展类别。然后，假设我们将它们全部放入通用列表中：

public static void Main()
{
     List<FlatScreenTV> tvList = new List<FlatScreenTV>();

     tvList.Add(new PhillipsFlatScreenTV());
     tvList.Add(new SamsungFlatScreenTV());
     tvList.Add(new SharpFlatScreenTV());
     tvList.Add(new VizioFlatScreenTV());

     FlatScreenTV tv = tvList[9]; // Randomly get one TV out of our huge list
}

问题：

我想访问此变量所属的“原创”品牌电视的特定属性。我知道该品牌，因为如果我致电tv.GetType()，则会返回正确的“原始”类型 - 不是 FlatScreenTV。但我需要能够将tv从FlatScreenTV转换回其原始类型，以便能够访问每个品牌的平板电视的特定属性。

问题＃1：如何正确地动态投射 - 没有临时黑客和巨大的if-else链条来粗暴猜测“原始”类型？

浏览类似的设计问题后，大多数答案都是：你不能。有人说要查看工厂模式，其他人说使用接口修改设计，但我不知道如何使用它们来解决这个问题。

问题2：那么，我应该如何设计这些类，以便我可以在上面的上下文中访问原始类型的特定属性？

问题＃3：遗传真的不好吗？

Answer 1

您的设计违反了“Liskov Substitution Principle”。换句话说，处理FlatScreenTV列表中的项目的代码不应该知道或关心派生类型是什么。

假设您的代码需要创建自定义远程控制GUI。仅仅知道每个电视的属性的名称和类型以自动生成UI可能就足够了。在这种情况下，您可以执行类似这样的操作来公开基类中的自定义属性：

public abstract class FlatScreenTV
{
    public FlatScreenTV()
    {
        CustomProperties = new Dictionary<string,object>();
    }

    public Dictionary<string,object> CustomProperties { get; private set; }
    public string Size { get; set; }
    public string ScreenType { get; set; }
}

public class PhillipsFlatScreenTV : FlatScreenTV
{
    public PhillipsFlatScreenTV()
    {
        BackLightIntensity = 0;
    }

    // Specific to Phillips TVs. Controls the backlight intensity of the LCD screen.
    public double BackLightIntensity 
    { 
        get { return (double)CustomProperties["BackLightIntensity"]; }
        set { CustomProperties["BackLightIntensity"] = value; }
    }
}

public class SamsungFlatScreenTV : FlatScreenTV
{
    public SamsungFlatScreenTV()
    {
        AutoShutdownTime = 0;
    }

    // Specific to Samsung TVs. Controls the time until the TV automatically turns off.
    public int AutoShutdownTime 
    {
        get { return (int)CustomProperties["AutoShutdownTime"]; }
        set { CustomProperties["AutoShutdownTime"] = value; }
    }
}

如果您确实需要直接使用派生类型，那么您应该考虑转向基于插件的架构。例如，您可能有这样的工厂方法：

IRemoteControlGUI GetRemoteControlGUIFor(FlatScreenTV tv)

会扫描你的插件并找到知道如何为你传入的特定类型的FlatScreenTV构建UI的那个。这意味着对于你添加的每个新的FlatScreenTV，你还需要创建一个知道如何的插件制作遥控器GUI。

Answer 2

Factory Pattern将是最好的方式

Answer 3

我可以提供部分答案：

首先阅读利斯科夫的替代原则。

其次，您正在创建从FlatScreenTV继承的对象，但显然没有任何目的，因为您希望通过它们的SubType（SpecificTVType）而不是它们的SuperType（FlatScreenTV）来引用它们 - 这是不好用的继承，因为它不使用继承lol。

如果您的代码想要访问特定于给定类型的属性，那么您确实希望将此代码封装在该类型中。否则，每次添加新的电视类型时，处理电视列表的所有代码都需要更新以反映出来。

所以你应该在FlatScreenTV上包含一个x的方法，并根据需要在电视中覆盖它。

所以基本上在你上面的Main方法中，不应该想我想要处理TVTypeX，你应该总是引用basetype，让继承和方法覆盖处理你实际处理的子类型的特定行为。 / p>

代码例如。

  public abstract class FlatScreenTV
  {
      public virtual void SetOptimumDisplay()
      {
         //do nothing - base class has no implementation here
      }
  }


  public class PhilipsWD20TV
  {
      public int BackLightIntensity {get;set;}

      public override void SetOptimumDisplay()
      {
          //Do Something that uses BackLightIntensity
      }

  }

Answer 4

“工厂方法适用于与抽象基类[interface]完全相同的多个具体类，并且不添加自己的属性。”

不，说起来比实际更实际，工厂方法可以为您提供具体类的对象，其中具体类必须有一些常用的方法和接口，但也有一些额外的特定属性。

有时候我每次调用都会使用一个创建相同类对象的方法，我需要多次调用它，有时候我会使用一个方法创建几个不同的类对象，这可能会令人困惑，也许是另一个问题。

并且，当您使用工厂模式时，您对具有许多选项的切换句的进一步评论通常会为具体类/具体对象提供标识符。这可以是字符串，整数，特殊类型ID或枚举类型。

您可以使用整数/枚举ID，并使用集合来查找具体类。

Answer 5

您仍然可以利用工厂。工厂IMO的目的是将构建各种电视的所有繁重工作放在一个地方。断然说＆＃34;工厂用于具有与抽象基类完全相同的实现的多个具体类＆＃34;忘记了多态性。

没有法律规定您不能使用工厂模式，因为子类声明了唯一的属性和方法。但是你可以越多地利用多态性，工厂模式就越有意义。另外作为一般指导方针，恕我直言，从基地开始构建的复杂程度越高，从长远来看，使用工厂就越好，因为你正在“封装变革”。 - 也就是说，由于不同的要求和固有的结构复杂性（设计分析决策，确定），构建具体类可能会发生变化。而这种变化只属于一个阶级 - 工厂。

试试这个：在抽象类中定义所有内容，然后为给定的电视子类编写特定于具体的代码，对于那些不适用的人，写一些标准＆＃34;我不做该＆＃34;代码。

考虑一下你的电视在通用术语中所做的所有事情：开启，关闭等等。在基类中为电视所做的所有通用事物编写一个虚拟方法shell - 这是模板方法的一个简单示例顺便说一下模式。然后根据需要在具体类中覆盖它们。

在基类中还有其他一些事情可以使它更具可筹性（这是一个技术术语，意思是＆＃34;引用子类作为基类，但是做了次级的事情＆＃34;）。

定义委托方法（非常强大但未充分利用）
使用params []获取动态方法参数列表
Make Property delegates
静态方法
声明属性和方法＆＃34; abstract＆＃34; - 强制子类实施，相对于＆＃34;虚拟＆＃34;
隐藏子类中的继承内容（通常使用＆＃34; new＆＃34;关键字以便有意识地传达它）
如果构造参数很多或很复杂，请创建一个专门设计用于将配置传递给工厂构建方法的类。

    public class TVFactory {

    public TV BuildTV(Brands thisKind) {
        TV newSet;

        switch (thisKind) {
            case Brands.Samsung :
                Samsung aSamsungTV = new Samsung();
                aSamsungTV.BacklightIntensity = double.MinVal;
                aSamsungTV.AutoShutdownTime = 45;    //oops! I made a magic number. My bad
                aSamsungTV.SetAutoShutDownTime = new delegate (newSet.SetASDT);
                newSet = aSamsungTV;

                break;
            . . .
        } // switch
    }

    //more build methods for setting specific parameters
    public TV BuildTV (Brands thisKind, string Size) { ... }

    // maybe you can pass in a set of properties to exactly control the construction.
    // returning a concrete class reference violates the spirit of object oriented programming 
    public Sony BuildSonyTV (...) {}

    public TV BuildTV (Brands thisKind, Dictionary buildParameters) { ... }
}

public class TV {
    public string Size { get; set; }
    public string ScreenType { get; set; }
    public double BackLightIntensity { get; set; }
    public int AutoShutdownTime { get; set; }

    //define delegates to get/set properties
    public delegate  int GetAutoShutDownTime ();
    public delegate void SetAutoShutDownTime (object obj);

    public virtual TurnOn ();
    public virtural TurnOff();

    // this method implemented by more than one concrete class, so I use that
    // as an excuse to declare it in my base.
    public virtual SomeSonyPhillipsOnlything () { throw new NotImplementedException("I don't do SonyPhillips stuff"); }

}

public class Samsung : TV {
    public Samsung() {
        // set the properties, delegates, etc. in the factory
        // that way if we ever get new properties we don't open umpteen TV concrete classes
        // to add it. We're only altering the TVFactory.
        // This demonstrates how a factory isolates code changes for object construction.
    }

    public override void TurnOn() { // do stuff }
    public override void TurnOn() { // do stuff }

    public void SamsungUniqueThing () { // do samsung unique stuff }

    internal void  SetASDT (int i) {
        AutoShutDownTime = i;
    }
}

// I like enumerations. 
//   No worries about string gotchas
//   we get intellense in Visual Studio
//   has a documentation-y quality
enum Brands {
    Sony
    ,Samsung
    ,Phillips
}

适合这个问题的设计/设计模式？

5 个答案: