internal ChildSelector With(Int32 step, Int32 offset, ISelector kind)
 {
     _step = step;
     _offset = offset;
     _kind = kind;
     return this;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="PropertyReflectionStrategy"/> class.
        /// </summary>
        /// <param name="selector">The selector component.</param>
        /// <param name="injectorFactory">The injector factory component.</param>
        public PropertyReflectionStrategy(ISelector selector, IInjectorFactory injectorFactory)
        {
            Ensure.ArgumentNotNull(selector, "selector");
            Ensure.ArgumentNotNull(injectorFactory, "injectorFactory");

            Selector = selector;
            InjectorFactory = injectorFactory;
        }

    /// <summary>
    /// 创建现有 CSS 选择器的自动缓存包装
    /// </summary>
    /// <param name="selector">已有的 CSS 选择器</param>
    /// <returns>对已有选择器的自动缓存的包装</returns>
    public static ISelector CreateCacheableWrapper( ISelector selector )
    {
      var cacheable = selector as CacheableSelector;
      if ( cacheable == null )
        cacheable = new CacheableCssSelectorWrapper( selector );

      return cacheable;
    }

    protected override bool IsEligible( ISelector leftSelector, IHtmlElement element )
    {
      var restrict = leftSelector as ContainerRestrict;
      if ( restrict != null )
        return restrict.RestrictContainer.Nodes().Contains( element );

      return leftSelector.IsEligibleBuffered( element.Parent() );
    }

 public string SelectDocument(ISelector selector)
 {
     IElementSelector elementSelector = selector as IElementSelector;
     if (elementSelector != null)
     {
         return elementSelector.Select(Document);
     }
     return selector?.Select(GetFirstSourceText());
 }

 public MultiSelector(
     IRangeSelector rangeSelector,
     ISelector inverseSelector,
     ISelector nullSelector)
 {
     _nullSelector = nullSelector;
     _inverseSelector = inverseSelector;
     _rangeSelector = rangeSelector;
 }

 public IList<string> SelectDocumentForList(ISelector selector)
 {
     var elementSelector = selector as IElementSelector;
     if (elementSelector != null)
     {
         return elementSelector.SelectList(Document);
     }
     return selector?.SelectList(GetFirstSourceText());
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="StandardProvider"/> class.
        /// </summary>
        /// <param name="type">The type (or prototype) of instances the provider creates.</param>
        /// <param name="planner">The planner component.</param>
        /// <param name="selector">The selector component.</param>
        public StandardProvider(Type type, IPlanner planner, ISelector selector)
        {
            Ensure.ArgumentNotNull(type, "type");
            Ensure.ArgumentNotNull(planner, "planner");
            Ensure.ArgumentNotNull(selector, "selector");

            Type = type;
            Planner = planner;
            Selector = selector;
        }

        /// <summary>
        /// 使用选择器从元素集中筛选出符合选择器要求的元素
        /// </summary>
        /// <param name="source">源元素集</param>
        /// <param name="selector">选择器</param>
        /// <returns>筛选结果</returns>
        public static IEnumerable<IHtmlElement> FilterBy( this IEnumerable<IHtmlElement> source, ISelector selector )
        {
            if ( source == null )
            return null;

              if ( selector == null )
            return source;

              return source.Where( selector.IsEligible );
        }

        /// <summary>
        /// 创建 CSS 层叠选择器对象
        /// </summary>
        /// <param name="relativeSelector">关系选择器</param>
        /// <param name="lastSelector">附加的最后一个选择器</param>
        public CssCasecadingSelector( CssRelativeSelector relativeSelector, ISelector lastSelector )
        {
            if ( relativeSelector == null )
            throw new ArgumentNullException( "relativeSelector" );

              if ( lastSelector == null )
            throw new ArgumentNullException( "lastSelector" );

              RelativeSelector = relativeSelector;
              LastSelector = lastSelector;
        }

 public void ConcludeSelector(ISelector selector)
 {
     if (!IsReady)
     {
         _selectors.Add(new CombinatorSelector
         {
             Selector = selector,
             Transform = null,
             Delimiter = null
         });
         IsReady = true;
     }
 }

        public GeneticAlgorithm(IRandom rand, Population candidates, Func<IOrganism, double> fitnessFunction, ISelector selector, IMutator mutator, ICrossover crossLinker, double elitismProportion, int maximumGenerations)
        {
            this.rand = rand;
            this.candidates = candidates;
            this.fitnessFunction = fitnessFunction;
            this.selector = selector;
            this.mutator = mutator;
            this.crossLinker = crossLinker;
            this.elitismProportion = elitismProportion;
            this._generationCount = 0;
            this.generationInformation = new Dictionary<int, double>();
            this.initialCount = candidates.Count;
            this.maximumGenerations = maximumGenerations;

            this.candidates.CalculateFitnesses(this.fitnessFunction);
        }

    /// <summary>
    /// 创建层叠选择器实例
    /// </summary>
    /// <param name="leftSelector">左选择器</param>
    /// <param name="combinator">结合符</param>
    /// <param name="rightSelector">右选择器</param>
    public static CssCasecadingSelector Create( ISelector leftSelector, char combinator, ISelector rightSelector )
    {
      if ( leftSelector == null )
        throw new ArgumentNullException( "leftSelector" );

      if ( rightSelector == null )
        throw new ArgumentNullException( "rightSelector" );


      var relativeSelctor = CreateRelativeSelector( leftSelector, combinator );
      var casecadingSelector = rightSelector as CssCasecadingSelector;

      if ( casecadingSelector != null )
        return Combine( relativeSelctor, casecadingSelector );

      return new CssCasecadingSelector( relativeSelctor, rightSelector );
    }

 private void RunProcessing()
 {
     try
     {
         int delay = config.HostRequestDelayMilliseconds();
         selector = CallSelectorFactory.createISelector(config);
         selector.setIErrorHandler(errorHandler);
         threadStarted.Set();
         while (!stopThread.WaitOne(delay))
         {
             if (false == selector.Run())
                 break;
         }
         lock (lockLog)
         {
             serviceEventLog.WriteEntry("Processing finished.");
         }
     }
     catch (ThreadAbortException) {/*ignore*/}
 }

 public void Deselect(ISelector selector)
 {
     if (selectors.ContainsKey(selector))
     {
         Border b = selectors[selector] as Border;
         if (Content == b)
         {
             object c = b.Child;
             Content = null;
             b.Child = null;
             Content = c;
         }
         else if (b.Parent is Border)
         {
             UIElement uie = b.Child;
             b.Child = null;
             Border parent = b.Parent as Border;
             parent.Child = null;
             parent.Child = uie;
         }
         selectors.Remove(selector);
     }
 }

 public void RegisterSelector(ISelector filter) {
    _filters.Add(filter);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="selector"></param>
 /// <param name="injectorFactory"></param>
 public EventReflectionStrategy( ISelector selector, IInjectorFactory injectorFactory )
 {
     Selector = selector;
     InjectorFactory = injectorFactory;
 }

 /// <summary>
 /// Registers a new selector for the specified name.
 /// Throws an exception if another selector for the given
 /// name is already added.
 /// </summary>
 /// <param name="name">The name of the CSS pseudo element.</param>
 /// <param name="selector">The selector to register.</param>
 public void Register(String name, ISelector selector)
 {
     _selectors.Add(name, selector);
 }

 public void AppendSelector(ISelector selector, CssCombinator combinator)
 {
     if (!IsReady)
     {
         _selectors.Add(new CombinatorSelector
         {
             Selector = combinator.Change(selector),
             Transform = combinator.Transform,
             Delimiter = combinator.Delimiter
         });
     }
 }

 public abstract bool TriplesExist(ISelector<Triple> selector);