C# NodeBase类代码示例

 public static void InitNodePopup(NodeBase node, NodeGraph graph)
 {
     currentNodePopupWindow = (NodeGraphPopupWindow)EditorWindow.GetWindow<NodeGraphPopupWindow>();
     currentNodePopupWindow.node = node;
     currentNodePopupWindow.graph = graph;
     currentNodePopupWindow.title = "Create a new GraphNode";
 }

 private RuleNode getLastRuleNode(NodeBase current)
 {
     if (!current.HasChild)
     {
         if (current is RuleNode)
         {
             return current as RuleNode;
         }
         else
         {
             return null;
         }
     }
     else
     {
         if (current.ChildNode is GroupNode)
         {
             return getLastRuleNode(((GroupNode)current.ChildNode).GroupRoot);
         }
         else
         {
             return getLastRuleNode(current.ChildNode);
         }
     }
 }

        public override IEnumerable<NodeBase> Expand(Context ctx, NodeBase expression, Label nextStatement)
        {
            foreach (var rule in KeyRule.Expand(ctx, Expr.GetMember(expression, "Key"), nextStatement))
                yield return rule;

            foreach (var rule in ValueRule.Expand(ctx, Expr.GetMember(expression, "Value"), nextStatement))
                yield return rule;
        }

 public virtual bool Connected(int i, NodeBase target)
 {
     return
         joints.Count != 0 &&
         i > 0 &&
         i < joints.Count &&
         joints[i].TargetId == target.Id;
 }

 public static New New2(BlockBase parent, string type, NodeBase length)
 {
     var ret = new New();
     ret.Parent = parent;
     ret.type = TypeReference.New(Types.GetType(parent, type), true);
     ret.Length = length;
     return ret;
 }

 public NodeJointPoint(Rect actionRect, Vector2 offset, NodeDrawableBase parent, NodeBase target = null)
 {
     ActionRect = actionRect;
     Offset = offset;
     Target = target != null ? target.FirstJoint : null;
     TargetId = target != null ? target.Id : NodeDrawableBase.NothingId;
     ParentId = parent.Id;
     //Debug.Log("in " + parent + ", ID=" + parent.ElementName);
 }

 public NodeUpdatedEvent(IAcSession acSession, NodeBase source, INodeUpdateIo output)
     : base(acSession, source)
 {
     if (output == null)
     {
         throw new System.ArgumentNullException("output");
     }
     this.Output = output;
 }

 public override IEnumerable<NodeBase> Expand(Context ctx, NodeBase expression, Label nextStatement)
 {
     yield return Expr.If(
         Expr.NotEqual(Literal as NodeBase, expression),
         Expr.Block(
             Expr.JumpTo(nextStatement)
         )
     );
 }

 public NodeCursorEventArgs(NodeBase source, string command, object tag, 
     int X, int Y, int ClickCount, GameUI.MouseButtons Button, GameUI.MouseClicks ClickType)
     : base(source, command, tag)
 {
     this.x = X;
     this.y = Y;
     this.clicks = ClickCount;
     this.button = Button;
     this.clicktype = ClickType;
 }

        public void FlashNode(NodeBase node)
        {
            if (node == null) return;

            this.flashNode = node;
            this.flashDuration = 0.0f;
            this.timerFlashItem.Enabled = true;

            this.folderView.EnsureVisible(this.folderView.FindNode(this.folderModel.GetPath(this.flashNode)));
        }

        public override IEnumerable<NodeBase> Expand(Context ctx, NodeBase expression, Label nextStatement)
        {
            for (var idx = 0; idx < ElementRules.Count; idx++)
            {
                var fieldName = string.Format("Item{0}", idx + 1);
                var rules = ElementRules[idx].Expand(ctx, Expr.GetMember(expression, fieldName), nextStatement);

                foreach (var rule in rules)
                    yield return rule;
            }
        }

 private Call ConvertToCall(NodeBase v)
 {
     if (v is Call)
         return v as Call;
     if (v is Variant)
         return Call.NewName(parent, (v as Variant).Name);
     if (!(v is Member))
         return Call.NewV(parent, v, null, null);
     var mem = v as Member;
     return Call.New(parent, mem.GetName(), mem.GetTarget(), null);
 }

 private NodeBase ReadIndex(NodeBase target)
 {
     var t = Read();
     if (t == "]" && target is Variant)
         return TypeOf.New(parent, Variant.NewName(parent, (target as Variant).Name + "[]"));
     else if (t != null)
         Rewind();
     var ret = Index.New(parent, target, ReadExpression());
     Check("配列", "]");
     return ret;
 }

        public void Test()
        {
            var tc = new TestClass();
            var etc = new List<TestClass>();
            var otc = new List<object>();

            var nodeBase = new NodeBase(null, null);
            nodeBase.Register(otc);
            nodeBase.Get<IEnumerable<TestClass>>();
            //TODO: this is the case needed by my immediate code
        }

 private NodeBase getEndNode(NodeBase current)
 {
     if (!current.HasChild)
     {
         return current;
     }
     else
     {
         return getEndNode(current.ChildNode);
     }
 }