假设我正在为硬件配件编写用户界面。该配件有两个版本 - 比如说 Widget Lite 和 Widget Pro。
Widget Pro 可以做 Widget Lite 可以做的所有事情，但是有更多的选择，并且可以做一些 Widget Lite 做不到的事情。更详细地说，Widget Lite 有一个通道，widget Pro 有两个，所以当涉及到类似于音量控制的东西时，我只需要一个用于 Lite 的控件，但两个用于 Pro 允许独立控制。
在我第一次尝试构建一个应用程序来处理这个问题时，我让代表 Widget Pro 的类扩展了 Widget Lite，但后来我得到了各种条件案例来处理看起来很难看的差异。有谁知道合适的设计模式来帮助解决这种情况？我的想象力在想出可能对我的搜索有帮助的同义词时出现空白。
我将从查看插件模式（依赖倒置的一种形式）开始。
尝试抽象 Lite 和 Pro 版本通用的接口，例如
interface IBaseWidget
{
IControl CreateVolumeControl();
// ... etc
}
在单独的程序集/dll 中，实现您的 Lite 和 Pro 小部件：
class LiteWidget : IBaseWidget
{
int _countCreated = 0;
IControl CreateVolumeControl()
{
_countCreated++;
if (_countCreated > 1)
{
throw new PleaseBuyTheProVersionException();
}
}
}
由于您不想通过 Lite 部署分发 Pro 版本，因此您需要在运行时加载 dll，例如通过约定（例如，您的基础应用程序查找名为 *Widget.dll 的 DLL），或通过配置，它找到了适用的具体实现IBaseWidget。根据@Bartek 的评论，理想情况下，您不希望您的基础引擎类工厂“了解”特定的具体类IBaseWidget.
访客模式可能对您有用。检查工厂。
访客班...
...为对象结构中的每个 ConcreteElement 类声明一个访问操作。该操作的名称和签名标识了向访问者发送访问请求的类。这让访问者可以确定被访问元素的具体类。然后访问者可以通过其特定的界面直接访问元素
这类似于 Vikdor 所说的抽象类实现。
这是一个 wiki 链接。
访问者模式需要一种支持单一调度和方法重载的编程语言。
我已经使用访问者模式提供了一个非常简单的实现，以满足您对 WidgetLite 和 Pro 的不同频道和音量设置的要求。我在评论中提到访问者模式将极大地帮助您减少 if-else 调用。
基本理念是您将控制权（例如音量）传递给小部件，它会知道如何根据需要使用它。因此，控制对象本身具有非常简化的实现。每个小部件的代码保持在一起！！
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WidgetVisitor
{
//This is the widget interface. It ensures that each widget type
//implements a visit functionality for each control. The visit function
//is overloaded here.
//The appropriate method is called by checking the parameter and this
//avoids the if-then logic elegantly
public interface Widget
{
void visit(Volume vol);
void visit(Channel chan);
void Display(AllControls ac);
}
//This is the interface which defines the controls. Each control that
//inherits this interface needs to define an "accept" method which
//calls the appropriate visit function of the right visitor,
//with the right control parameter passed through its call!
//This is how the double dispatch works.
//Double dispatch: A mechanism that dispatches a function call to different concrete
//functions depending on the runtime types of two objects involved in the call.
public interface WidgetControls
{
void accept(Widget visitor);
}
//I have implemented the volume control and channel control
//Notice how the code for defining each control is the SAME
//in visitor pattern! This is double dispatch in action
public class Volume : WidgetControls
{
public int volLevel { get; set; }
public int volJazz { get; set; }
public int volPop { get; set; }
public void accept(Widget wc)
{
wc.visit(this);
}
}
public class Channel : WidgetControls
{
public int channelsProvided { get; set; }
public int premiumChannels { get; set; }
public void accept(Widget wc)
{
wc.visit(this);
}
}
//Widget lite implementation. Notice the accept control implementation
//in lite and pro.
//Display function is an illustration on an entry point which calls the
//other visit functions. This can be replaced by any suitable function(s)
//of your choice
public class WidgetLite : Widget
{
public void visit(Volume vol)
{
Console.WriteLine("Widget Lite: volume level " + vol.volLevel);
}
public void visit(Channel cha)
{
Console.WriteLine("Widget Lite: Channels provided " + cha.channelsProvided);
}
public void Display(AllControls ac)
{
foreach (var control in ac.controls)
{
control.accept(this);
}
Console.ReadKey(true);
}
}
//Widget pro implementation
public class WidgetPro : Widget
{
public void visit(Volume vol)
{
Console.WriteLine("Widget Pro: rock volume " + vol.volLevel);
Console.WriteLine("Widget Pro: jazz volume " + vol.volJazz);
Console.WriteLine("Widget Pro: jazz volume " + vol.volPop);
}
public void visit(Channel cha)
{
Console.WriteLine("Widget Pro: Channels provided " + cha.channelsProvided);
Console.WriteLine("Widget Pro: Premium Channels provided " + cha.premiumChannels);
}
public void Display(AllControls ac)
{
foreach (var control in ac.controls)
{
control.accept(this);
}
Console.ReadKey(true);
}
}
//This is a public class that holds and defines all the
//controls you want to define or operate on for your widgets
public class AllControls
{
public WidgetControls [] controls { get; set; }
public AllControls(int volTot, int volJazz, int volPop, int channels, int chanPrem)
{
controls = new WidgetControls []
{
new Volume{volLevel = volTot, volJazz = volJazz, volPop = volPop},
new Channel{channelsProvided = channels, premiumChannels = chanPrem}
};
}
}
//finally, main function call
public class Program
{
static void Main(string[] args)
{
AllControls centralControl = new AllControls(3, 4, 2, 5, 10);
WidgetLite wl = new WidgetLite();
WidgetPro wp = new WidgetPro();
wl.Display(centralControl);
wp.Display(centralControl);
}
}
}
我强烈建议你有一个Widget既来自Widget Lite又Widget Pro派生的基类。
public class Widget {}
public class WidgetLite : Widget {}
public class WidgetPro : Widget {}
Pro拥有基类和基类内部共享的属性/方法Lite。这对您来说是一个更清洁的设计。
我会这样做：
AbstractWidget (Abstract class)
/\
/ \
/ \
/ \
/ \
WidgetLite WidgetPro
公共代码将进入 AbstractWidget（抽象，因为它不应该被实例化），这两个类之间不同的行为将进入具体类。