C# XNode.Interfaces方法代码示例

        protected virtual void Apply(XNode node, JsonSerializer serializer, JObject obj)
        {
            Contract.Requires<ArgumentNullException>(node != null);
            Contract.Requires<ArgumentNullException>(serializer != null);
            Contract.Requires<ArgumentNullException>(obj != null);

            RemotesToObject(node.Interfaces<object>(), obj, serializer);
        }

        /// <summary>
        /// Gets the <see cref="RemoteDescriptor"/> for the given remote interface on the given <see cref="XNode"/>.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="interfaceName"></param>
        /// <returns></returns>
        static RemoteDescriptor GetRemoteDescriptor(XNode node, string interfaceName)
        {
            Contract.Requires<ArgumentNullException>(node != null);
            Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(interfaceName));

            return RemoteObjectJsonConverter.GetRemotes(node.Interfaces<object>())
                .FirstOrDefault(i => i.Type.FullName == interfaceName);
        }

        /// <summary>
        /// Invokes the applicable listeners for this node.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="evt"></param>
        void InvokeListeners(XNode node, Event evt)
        {
            Contract.Requires<ArgumentNullException>(node != null);
            Contract.Requires<ArgumentNullException>(evt != null);

            // Initialize event's currentTarget attribute to the object for which these steps are run.
            evt.currentTarget = node;

            // invoke registered listeners
            foreach (var registration in node.Interface<EventTarget>().state.registrations)
            {
                // If event's stop immediate propagation flag is set, terminate the invoke algorithm.
                if (evt.stopImmediatePropagation)
                    return;

                // If event's type attribute value is not listener's type, terminate these substeps (and run them for
                // the next event listener).
                if (evt.type != registration.EventType)
                    continue;

                // If event's eventPhase attribute value is CAPTURING_PHASE and listener's capture is false, terminate
                // these substeps (and run them for the next event listener).
                if (evt.eventPhase == EventPhase.Capturing && registration.Capture == false)
                    continue;

                // If event's eventPhase attribute value is BUBBLING_PHASE and listener's capture is true, terminate
                // these substeps (and run them for the next event listener).
                if (evt.eventPhase == EventPhase.Bubbling && registration.Capture == true)
                    continue;

                // Call listener's callback's handleEvent, with the event passed to this algorithm as the first
                // argument and event's currentTarget attribute value as callback this value.
                invoker.Invoke(() =>
                    registration.Listener.HandleEvent(evt));
            }

            // invoke listeners available directly as interfaces
            foreach (var listener in node.Interfaces<IEventListener>())
            {
                // If event's stop immediate propagation flag is set, terminate the invoke algorithm.
                if (evt.stopImmediatePropagation)
                    return;

                invoker.Invoke(() =>
                    listener.HandleEvent(evt));
            }
        }