不要针对特定的类型进行工作，而是针对接口进行工作。
以下展示了外观模式和适配器模式的混合使用，将外部数据“转换”为一个明确定义的接口（IDocument），有效地抽象出你正在处理的事物。
示例1：关于接口的查询
这里是你将要处理的类型：
public interface IDocument {
string Name { get; set; }
}
public interface IMetadata {
string[] Tags { get; set; }
}
这是您自己的表述，如果需要的话：
public class RichDocument : IDocument, IMetadata {
public string Name { get; set; }
public string[] Tags { get; set; }
}
这是用于外部数据的包装器：
（混合了门面和/或适配器概念）
public class ExternalClass {
public string Whatever { get; set; }
}
public class ExternalDocument : IDocument {
private readonly ExternalClass _class;
public ExternalDocument(ExternalClass @class) {
_class = @class;
}
public string Name {
get { return _class.Whatever; }
set { _class.Whatever = value; }
}
}
并演示如何使用所有这些：
internal class Demo1 {
public Demo1() {
var documents = new List<IDocument> {
new ExternalDocument(new ExternalClass()),
new RichDocument()
};
foreach (var document in documents){
var name = document.Name;
Console.WriteLine(name);
var metadata = document as IMetadata;
if (metadata != null) {
Console.WriteLine(metadata.Tags);
}
}
}
}
例子2：有关组件的查询
这需要更多的涉及，通过将概念推向以统一的方式处理所有内容，您可以在.NET框架、游戏开发或其他任何地方找到它...
您将使用以下定义进行工作：
public interface IContainer {
IList<IComponent> Components { get; }
}
public interface IComponent {
}
一些你会查询的组件：
public interface IDocument : IComponent {
string Name { get; set; }
}
public interface IMetadata : IComponent {
string[] Tags { get; set; }
}
你的“内部”类型：
public class Container : IContainer {
public Container() {
Components = new List<IComponent>();
}
public IList<IComponent> Components { get; }
}
你的“包装器”用于外部数据：
public class ExternalClass {
public string Whatever { get; set; }
}
public class ExternalContainer : IContainer {
private readonly List<IComponent> _components;
public ExternalContainer(ExternalClass @class) {
_components = new List<IComponent> {new ExternalDocument(@class)};
}
public IList<IComponent> Components {
get { return _components; }
}
}
public class ExternalDocument : IDocument {
private readonly ExternalClass _class;
public ExternalDocument(ExternalClass @class) {
_class = @class;
}
public string Name {
get { return _class.Whatever; }
set { _class.Whatever = value; }
}
}
并且有一个用法示例：
public class Demo2 {
public Demo2() {
var containers = new List<IContainer> {
new ExternalContainer(new ExternalClass()),
new Container()
};
foreach (var container in containers) {
var components = container.Components;
var document = components.OfType<IDocument>().FirstOrDefault();
if (document != null) {
Console.WriteLine(document.Name);
}
var metadata = components.OfType<IMetadata>().FirstOrDefault();
if (metadata != null) {
Console.WriteLine(metadata.Tags);
}
}
}
}
注意事项
继承的问题在于它是一种非常死板的方法，一旦开始使用，到某个时候你想要回退，就很难摆脱它。
通过针对抽象化进行工作，事情更加灵活，事物也解耦合。
以下是两个例子，可能会激励您改变您的方法：
组合优于继承
使用组件
