设计模式之美：Extension Object（扩展对象）

索引

意图

结构

参与者

适用性

效果

相关模式

实现

实现方式（一）：使用示例结构实现 Extension Object。

实现方式（二）：使用泛型实现 IExtensibleObject<T> 接口。

[b]意图[/b]

预期对象的接口将在未来被扩展。通过额外的接口来定义扩展对象。

Anticipate that an object’s interface needs to be extended in the future.

Additional interfaces are defined by extension objects..

[b]结构[/b]



[b]参与者[/b]

Subject

定义抽象主体对象。其定义用于查询是否包含特定扩展的接口。

Extension

所有扩展类的抽象基类。可以定义负责管理扩展自身的操作。

Extension 知道其是谁的扩展。

ConcreteSubject

具体的主体类。实现基类定义的 GetExtension 方法并返回相应的扩展对象。

AbstractExtension

特定种类的扩展类的抽象基类。

ConcreteExtension

继承并实现 AbstractionExtension 类。实现特定的扩展功能。

[b]适用性[/b]

当以下情况成立时可以使用 Extension Object 模式：

当需要为已有对象额外添加全新的或无法预见的接口时。

抽象的主要接口在不同的客户类中拥有不同的角色时。

无法通过子类型化来扩展接口行为时。

[b]效果[/b]

扩展对象促进了增加新扩展功能。

类的主要抽象接口不会过于膨胀。

接口的主要抽象在不同的子系统中可实现不同的角色。

客户类变得更加复杂。

需要控制对扩展对象的滥用。

[b]相关模式[/b]

Visitor 模式可以为层级的类结构增加新的行为。Visitor 模式与 Extension Object 模式拥有类似的益处。相比 Visitor 模式，Extension Object 模式不需要一个稳固的类层级结构，并且也不引入循环依赖。

Decorator 模式是另一个可以扩展类的行为的模式。客户类在使用 Decorator 对象时的透明性比使用 Extension Object 更好。在使用窄接口或需要增强已知接口时更适合使用 Decorator 模式。

Adapter 模式支持适配一个已知接口。Extension Object 模式支持附加的接口。当对象需要对扩展接口进行适配时可以同时使用 Extension Object 模式和 Adapter 模式。

[b]实现[/b]

实现方式（一）：使用示例结构实现 Extension Object。

namespace ExtensionObjectPattern.Implementation1
{
public abstract class Subject
{
public abstract void Operation1();
public abstract Extension GetExtension(string extensionType);
}

public abstract class Extension
{
protected Subject _owner;

public Extension(Subject owner)
{
_owner = owner;
}

public abstract void DoSomething();
}

public abstract class AbstractExtension : Extension
{
public AbstractExtension(Subject owner)
: base(owner)
{
}
}

public class ConcreteExtension : AbstractExtension
{
public ConcreteExtension(Subject owner)
: base(owner)
{
}

public override void DoSomething()
{
// do something
_owner.Operation1();
}
}

public class ConcreteSubject : Subject
{
private ConcreteExtension _extension;

public ConcreteSubject()
{
_extension = new ConcreteExtension(this);
}

public override void Operation1()
{
// do something
}

public override Extension GetExtension(string extensionType)
{
if (extensionType == "some type")
{
return this._extension;
}

return null;
}
}

public class Client
{
public void TestCase1()
{
Subject subject = new ConcreteSubject();
Extension extension = subject.GetExtension("some type");
extension.DoSomething();
}
}
}

实现方式（二）：使用泛型实现 IExtensibleObject<T> 接口。

namespace ExtensionObjectPattern.Implementation2
{
public abstract class Subject : IExtensibleObject<Subject>
{
public abstract void Operation1();
public abstract IEnumerable<IExtension<Subject>> Extensions { get; }
}

public interface IExtensibleObject<T>
where T : class, IExtensibleObject<T>
{
IEnumerable<IExtension<T>> Extensions { get; }
}

public interface IExtension<T>
where T : class, IExtensibleObject<T>
{
void Attach(T owner);
void Detach(T owner);
}

public abstract class Extension : IExtension<Subject>
{
protected List<Subject> _owners;

public void Attach(Subject owner)
{
_owners.Add(owner);
}

public void Detach(Subject owner)
{
_owners.Remove(owner);
}

public abstract void DoSomething();
}

public class ConcreteExtension : Extension
{
public override void DoSomething()
{
// do something
foreach (var item in _owners)
{
item.Operation1();
}
}
}

public class ConcreteSubject : Subject
{
private List<Extension> _extensions = new List<Extension>();

public ConcreteSubject()
{
Extension extension = new ConcreteExtension();
extension.Attach(this);

_extensions.Add(extension);
}

public override void Operation1()
{
// do something
}

public override IEnumerable<IExtension<Subject>> Extensions
{
get
{
return _extensions;
}
}
}

public class Client
{
public void TestCase1()
{
Subject subject = new ConcreteSubject();

foreach (var extension in subject.Extensions)
{
(extension as Extension).DoSomething();
}
}
}
}

《设计模式之美》为 Dennis Gao 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。