My.Ioc 代码示例——使用条件绑定和元数据（可选）构建插件树
本文旨在通过创建一棵插件树来演示条件绑定和元数据的用法。
说“插件树”也许不大妥当，因为在一般观念中，谈到插件树，我们很容易会想到 Winform/Wpf 中的菜单。举例来说，如果要在 Winform 中创建一个层级菜单，我们可以使用类似如下代码：
// Create File menu var newMenu = new ToolStripMenuItem(); var localProjectMenu = new ToolStripMenuItem(); var remoteProjectMenu = new ToolStripMenuItem(); var openMenu = new ToolStripMenuItem(); openMenu.DropDownItems.AddRange(new ToolStripItem[] { localProjectMenu, remoteProjectMenu}); var fileMenu = new ToolStripMenuItem(); fileMenu.DropDownItems.AddRange(new ToolStripItem[] { openMenu, newMenu }); fileMenu.Size = new System.Drawing.Size(39, 21); fileMenu.Text = "&File"; // Create Edit menu var undoMenu = new ToolStripMenuItem(); var redoMenu = new ToolStripMenuItem(); var editMenu = new ToolStripMenuItem(); editMenu.DropDownItems.AddRange(new ToolStripItem[] { undoMenu, redoMenu}); // Create MenuStrip var menuStrip = new MenuStrip(); menuStrip.Items.AddRange(new ToolStripItem[] { fileMenu, editMenu});
这样创建出来，就是一个类似如下结构的菜单树：
在上述示例中，我们通过分别创建各个菜单对象（并为各个菜单指定不同的属性，例如 Text/Size），然后将这些菜单对象插入对应的上级菜单或 MenuStrip 中，最后组装成一棵菜单树。这里，菜单类型（ToolStripMenuItem/ToolStripItem 等类型）并没有增加，增加的只是菜单类型的实例数量。换句话说，此处我们是通过增加对象实例而不是对象类型的数量来实现复用。
在 My.Ioc 中，通过为相同契约 (Contract Type) 提供多个不同实现，并将这些实现分别注册到容器中，同时结合 My.Ioc 的条件绑定和元数据功能，我们也可以方便地构建起一棵树。请看下面的示例代码：
using System; using System.Collections.Generic; using My.Ioc; namespace TreeBuilder { #region Tree/Node Types public interface INode { string ParentName { get; set; } string Name { get; } IEnumerable<INode> ChildNodes { get; } } public abstract class Node : INode { string _name; public string ParentName { get; set; } public string Name { get { _name = _name ?? GetType().Name; return _name; } } public virtual IEnumerable<INode> ChildNodes { get { return null; } } } #region Level 1 public class Tree { readonly string _name; readonly IEnumerable<INode> _childNodes; public Tree(IEnumerable<INode> childNodes) { if (childNodes == null) throw new ArgumentException(); _name = GetType().Name; foreach (var childNode in childNodes) childNode.ParentName = _name; _childNodes = childNodes; } public string Name { get { return _name; } } public IEnumerable<INode> ChildNodes { get { return _childNodes; } } } #endregion #region Level 2 public abstract class CompositeNode : Node { readonly IEnumerable<INode> _childNodes; protected CompositeNode(IEnumerable<INode> childNodes) { if (childNodes == null) throw new ArgumentException(); foreach (var childNode in childNodes) childNode.ParentName = Name; _childNodes = childNodes; } public override IEnumerable<INode> ChildNodes { get { return _childNodes; } } } public class ListNode : CompositeNode { public ListNode(List<INode> childNodes) : base(childNodes) { } } public class ArrayNode : CompositeNode { public ArrayNode(INode[] childNodes) : base(childNodes) { } } #endregion #region Level 3 public class ChildNode1 : Node { } public class ChildNode2 : Node { } public class ChildNode3 : Node { } public class ChildNode4 : Node { } public class ChildNode5 : Node { } public class ChildNode6 : Node { } public class ChildNode7 : Node { } public class ChildNode8 : Node { } #endregion #endregion class Program { static void Main(string[] args) { IObjectContainer container = new ObjectContainer(false); Register(container); // Try to get an observer IObjectObserver<Tree> treeObserver; if (!container.TryGetObserver(out treeObserver)) throw new InvalidOperationException(); // Resolve the tree using the observer var tree = container.Resolve(treeObserver); //var tree = container.Resolve<Tree>(); PrintTreeMembers(tree, 1); // Add more nodes at runtime container.Register(typeof(INode), typeof(ChildNode8)) .WhenParentMetadata((mata) => string.Equals("ArrayNode", mata)); container.Register<INode, ChildNode7>() .WhenParentTypeIs<ListNode>(); // Commit the registrations to the registry as usual. container.CommitRegistrations(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); // Resolve the tree again tree = container.Resolve(treeObserver); //tree = container.Resolve<Tree>(); PrintTreeMembers(tree, 2); Console.ReadLine(); } static void Register(IObjectContainer container) { container.Register<Tree>(); container.Register<INode, ArrayNode>() .WhenParentTypeIs<Tree>() .Set("ArrayNode"); container.Register<INode, ListNode>() .WhenParentTypeIs<Tree>() .Set("ListNode"); #region Inject into ArrayNode container.Register(typeof(INode), typeof(ChildNode1)) .WhenParentMetadata((mata) => string.Equals("ArrayNode", mata)); container.Register<INode, ChildNode2>() .WhenParentTypeIs<ArrayNode>(); container.Register<INode, ChildNode3>() .WhenParentTypeIs<ArrayNode>(); container.Register<INode, ChildNode4>() .WhenParentTypeIs<ArrayNode>(); #endregion #region Inject into ListNode container.Register<INode, ChildNode5>() .WhenParentTypeIs<ListNode>(); container.Register<INode, ChildNode6>() .WhenParentTypeIs<ListNode>(); #endregion // Commit the registrations to the registry. container.CommitRegistrations(); } static void PrintTreeMembers(Tree tree, int time) { if (tree == null) throw new ArgumentException(); Console.WriteLine(time); Console.WriteLine("================================================="); Console.WriteLine(tree.Name); // Breadth first traversal var allNodes = new List<INode>(); if (tree.ChildNodes == null) return; allNodes.AddRange(tree.ChildNodes); for (int i = 0; i < allNodes.Count; i++) { var node = allNodes[i]; Console.WriteLine(node.ParentName + "/" + node.Name); if (node.ChildNodes != null) allNodes.AddRange(node.ChildNodes); } } } }
请注意，与前一种方式相比，以这种方式来构建树的思想实际上是有所不同的。从本质上来说，这是一种通过增加（派生）类型来实现复用的手段，而前一种方式是通过增加对象实例来实现复用，这一点我们前面说过了。与前一种复用相比，这种复用有一个缺点，那就是当我们将这些类型注册到容器中时，My.Ioc 会为每个派生类型生成一个注册项，而每生成一个注册项时都会附带生成并缓存一大堆中间类（比如 ObjectBuilder/Lifetime/Injector/DependencyProvider 等），这无疑会多耗用一些内存。而前一种复用方式则无此弊病，因为它只是简单增加对象实例而已，这也是我在本文开头时说“不大妥当”的原因。
尽管如此，恰如我们在文章开头提到的，我们的目的是阐述条件绑定和元数据的用法，通过这个示例，我们达到了这个目的。至于如何更好地使用条件绑定和元数据的功能，留给各位自己去发挥好了。
源码可在此处下载，压缩包中包含了 My.Ioc 框架的源码和本示例以及其他一些示例的源码。
