C# DataFrame.CloneFrame方法代码示例

        /// <summary>
        /// Log a packet from the graph
        /// </summary>
        /// <param name="tag">A textual tag for the frame</param>
        /// <param name="color">The color to display the frame (if applicable)</param>
        /// <param name="frame">The frame to log, note this must be cloned to preserve its value</param>
        /// <param name="logAsBytes">Indicates whether the packet should be logged as a byte array</param>
        /// <param name="path">Selection path for which part of the packet to log</param>
        private void OnLogPacket(string tag, ColorValue color, DataFrame frame, bool logAsBytes, string path)
        {
            EventHandler<LogPacketEventArgs> logPacketEvent = LogPacketEvent;

            if (logPacketEvent != null)
            {
                DataFrame logFrame = null;
                if (path != "/")
                {
                    DataNode node = frame.SelectSingleNode(path);

                    if (node != null)
                    {
                        node = node.CloneNode();

                        DataKey key = node as DataKey;
                        if (key != null)
                        {
                            logFrame = new DataFrame(key);
                        }
                        else
                        {
                            logFrame = new DataFrame();
                            logFrame.Root.AddSubNode(node);
                        }

                        if (logAsBytes)
                        {
                            logFrame.ConvertToBasic();
                        }
                    }
                }
                else
                {
                    logFrame = logAsBytes ? new DataFrame(frame.ToArray()) : frame.CloneFrame();
                }

                if (logFrame != null)
                {
                    logPacketEvent(this, new LogPacketEventArgs(tag, Uuid, logFrame, color, NetworkDescription));
                }
            }
        }

        /// <summary>
        /// Add a simple packet with a tag and a frame
        /// </summary>
        /// <param name="tag">The tag to add</param>
        /// <param name="frame">The frame to add, this will be cloned before putting in log</param>
        /// <returns>The logged packet</returns>
        public LogPacket AddPacket(string tag, DataFrame frame)
        {
            LogPacket ret = new LogPacket(tag, Guid.NewGuid(), "Packet Log", frame.CloneFrame(), ColorValue.White);
            AddPacket(ret);

            return ret;
        }

        /// <summary>
        /// Set the frame to edit
        /// </summary>
        /// <param name="frame">The data frame</param>        
        /// <param name="selector">Root selection path</param>
        /// <param name="color">The colour to display the frame in (if applicable)</param>
        public void SetFrame(DataFrame frame, string selector, Color color)
        {
            toolStripButtonSnapshot.Enabled = false;
            toolStripButtonUndo.Enabled = false;
            _oldFrame = frame;
            _currFrame = frame.CloneFrame();
            _selector = selector;
            _color = color;

            UpdateFrame();
        }

        /// <summary>
        /// Internal write function
        /// </summary>
        /// <param name="frame">The frame to write</param>
        /// <param name="nodes">The list of nodes to write to</param>
        private void WriteOutput(DataFrame frame, OutputNode[] nodes)
        {
            try
            {
                // Leave this like it is for legacy reasons.
                if (frame == null)
                {
                    foreach (OutputNode node in nodes)
                    {
                        node.Node.Shutdown(this);
                    }
                }
                else
                {
                    _outputPacketCount++;
                    _byteCount += frame.Length;
                    if (LogOutput)
                    {
                        LogPacket(String.Format("{0} Output", Name), new ColorValue(255, 255, 255), frame, false);
                    }

                    if (nodes.Length == 1)
                    {
                        // If we only have one output then don't need to clone
                        nodes[0].Node.Input(frame);
                    }
                    else
                    {
                        foreach (OutputNode node in nodes)
                        {
                            DataFrame newFrame = frame.CloneFrame();

                            node.Node.Input(newFrame);
                        }
                    }
                }
            }
            catch (ThreadAbortException)
            {
                // If we get a thread abort it probably means we want to go away
                throw;
            }
            catch (Exception ex)
            {
                // Back stop, do nothing but write to log
                LogException(ex);
            }
        }