public HtmlMeta( IHtmlElement element )
        {
            if ( !element.Name.EqualsIgnoreCase( "meta" ) )
            throw new InvalidOperationException();

              Element = element;
        }

 public void BindData( IHtmlElement element, object data )
 {
     if ( IsComplexData( data.GetType() ) )
     BindComplexData( element, data );
       else
     BindSimpleData( element, data );
 }

        private StyleManager( IHtmlElement element )
        {
            if ( element == null )
            throw new ArgumentNullException( "element" );

              _element = element;
        }

        /// <summary>
        /// 尝试生成元素开始标签的HTML形式
        /// </summary>
        /// <param name="element">要生成HTML的元素</param>
        /// <param name="selfClosed">指示是否应产生自结束符号</param>
        /// <returns></returns>
        public static string GenerateTagHtml( IHtmlElement element, bool selfClosed )
        {
            if ( element == null )
            throw new ArgumentNullException( "element" );

              var builder = new StringBuilder( 20 );

              builder.Append( "<" );
              builder.Append( element.Name );

              foreach ( var attribute in element.Attributes() )
              {
            builder.Append( " " );
            builder.Append( attribute.Name );
            if ( attribute.AttributeValue != null )
            {
              var specification = element.Document.HtmlSpecification;

              if ( ( specification.IsUriValue( attribute ) || specification.IsScriptValue( attribute ) ) && !attribute.AttributeValue.Contains( '"' ) )
            builder.Append( "=\"" ).Append( attribute.AttributeValue ).Append( "\"" );
              else
            builder.Append( "=\"" ).Append( HtmlEncoding.HtmlAttributeEncode( attribute.AttributeValue ) ).Append( "\"" );
            }
              }

              if ( selfClosed )
            builder.Append( " /" );

              builder.Append( ">" );
              return builder.ToString();
        }

 public IEnumerable<IHtmlElement> Apply(IEnumerable<IHtmlElement> elems, IHtmlElement root = null) {
     var result = new List<IHtmlElement>();
     foreach (var elem in elems) {
         if (this.Check(elem,root)!=null) result.Add(elem);
     }
     return result;
 }

    /// <summary>
    /// 创建一个 HTML 表单对象
    /// </summary>
    /// <param name="element">表单元素</param>
    /// <param name="configuration">表单配置</param>
    /// <param name="provider">表单控件提供程序</param>
    public HtmlForm( IHtmlElement element, FormConfiguration configuration = null, IFormProvider provider = null )
    {

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

      var document = element.Document;

      if ( document == null )
        throw new InvalidOperationException();


      var modifier = document.DomModifier as ISynchronizedDomModifier;
      if ( modifier == null )
        throw new InvalidOperationException();


      SyncRoot = modifier.SyncRoot;
      
      _element = element;

      Configuration = configuration ?? new FormConfiguration();
      Provider = provider ?? new StandardFormProvider();


      RefreshForm();
    }

 public static ApiPagedResult<List<ProductItem>> GetProductItemList(IHtmlElement stockTable, int page = 1)
 {
     var result = new ApiPagedResult<List<ProductItem>>();
     var tableEntity = new TableEntity(stockTable);
     if (tableEntity.TBody.TrList.Count == 1 && tableEntity.TBody.TrList[0].TrElement.InnerHtml().IndexOf("没有符合条件的结果") != -1)
     {
         result.HasMore = false;
         result.Data = new List<ProductItem>();
     }
     else
     {
         var list = tableEntity.TBody.TrList.Select(x => x.GetProductItem()).ToList();
         var nextUrl = stockTable.Container.Find("a.page-next");
         if (nextUrl.Any())
         {
             var pageNext = UrlHelper.GetIntValue(nextUrl.First().Attribute("href").AttributeValue, "page");
             result.HasMore = pageNext > page;
         }
         else
         {
             result.HasMore = false;
         }
         result.Data = list;
     }
     tableEntity.Dispose();
     return result;
 }

    internal FormButtonGroupItem( FormButtonGroup groupControl, IHtmlElement element )
      : base( groupControl )
    {

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

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

      if ( !element.Name.EqualsIgnoreCase( "input" ) )
        throw new InvalidOperationException();

      if ( !element.Attribute( "name" ).Value().EqualsIgnoreCase( groupControl.Name ) )
        throw new InvalidOperationException();

      var type = element.Attribute( "type" ).Value();

      if ( type.EqualsIgnoreCase( "radio" ) )
        ButtonType = FormGroupButtonType.RadioButton;

      else if ( type.EqualsIgnoreCase( "checkbox" ) )
        ButtonType = FormGroupButtonType.RadioButton;

      else
        throw new InvalidOperationException();

      Element = element;
    }

        public void Count_of_empty_collection_should_be_0()
        {
            var elements = new IHtmlElement[] { };
            var collection = new HtmlCollection(elements);

            Assert.That(collection.Count, Is.EqualTo(0));
        }

    internal RouteValueDictionary GetRouteValues( IHtmlElement element, bool clearRouteAttributes )
    {

      var routeValues = new RouteValueDictionary();

      var inherits = element.Attribute( "inherits" ).Value();

      if ( inherits != null )
      {

        var inheritsKeys = GetInheritsKeys( inherits );

        foreach ( var key in inheritsKeys )
          routeValues.Add( key, RequestContext.RouteData.Values[key] );

      }


      if ( !MvcEnvironment.Configuration.DisableUnderscorePrefix )
        CustomRouteValues( element, "_", routeValues, clearRouteAttributes );
      
      CustomRouteValues( element, "route-", routeValues, clearRouteAttributes );

      return routeValues;
    }

 protected virtual void ApplyAdorners(IHtmlElement cell)
 {
     foreach (var adorner in Adorners)
     {
         adorner.ApplyTo(cell);
     }
 }

 public override IHtmlElement Check(IHtmlElement elem, IHtmlElement root = null)
 {
     if (elem == root) return null;
     if (AscendantFilters.Count == 0) throw new ArgumentException("Ascendant Filter is required.");
     var at = AscendantFilters.Count-1;
    
     
     var filter = AscendantFilters[at];
     if (filter.Check(elem, root) == null || --at<0) return null;
     filter = AscendantFilters[at];
     var p = elem.ParentNode;
     while (p != null)
     {
         
         var checkResult = filter.Check(p,root);
         if (checkResult != null) {
             
             if (--at < 0) return elem;
             p = checkResult.ParentNode;
             continue;
         }
         if (p == root) break;
         p = p.ParentNode;  
           
     }
     return null;
 }

        /// <summary>
        /// 检查元素是否符合选择器
        /// </summary>
        /// <param name="element">要检验的元素</param>
        /// <returns>是否符合选择器</returns>
        public virtual bool IsEligible( IHtmlElement element )
        {
            if ( element == null )
            return false;

              return IsEligible( LeftSelector, element );
        }

    internal HtmlListItem( IHtmlElement element )
    {
      if ( !element.Name.EqualsIgnoreCase( "li" ) )
        throw new FormatException( "HTML 文档格式不正确，列表元素只能包含 li 元素" );

      _element = element;
    }

        /// <summary>
        /// 检查元素是否符合指定选择器要求，并缓存结果于元素当前文档版本
        /// </summary>
        /// <param name="selector">选择器</param>
        /// <param name="element">元素</param>
        /// <returns>是否符合选择器要求</returns>
        public static bool IsEligibleBuffered( this ICssSelector selector, IHtmlElement element )
        {
            if ( selector == null )
            throw new ArgumentNullException( "selector" );

              if ( element == null )
            return selector.IsEligible( element );

              var cacheContainer = element.Document as IVersionCacheContainer;
              if ( cacheContainer == null )
            return selector.IsEligible( element );

              lock ( cacheContainer.SyncRoot )
              {
            var cache = cacheContainer.CurrenctVersionCache[selector] as Dictionary<IHtmlElement, bool>;

            if ( cache != null )
            {

              bool result;
              if ( cache.TryGetValue( element, out result ) )
            return result;
            }

            else
              cacheContainer.CurrenctVersionCache[selector] = cache = new Dictionary<IHtmlElement, bool>();

            return cache[element] = selector.IsEligible( element );

              }
        }

    /// <summary>
    /// 检查元素是否符合选择器要求（此方法会自动缓存结果）
    /// </summary>
    /// <param name="element">要检查的元素</param>
    /// <returns>是否符合选择器的要求</returns>
    public virtual bool IsEligible( IHtmlElement element )
    {
      if ( element == null )
        return false;

      var cacheContainer = element.Document as IVersionCacheContainer;
      if ( cacheContainer == null )
        return IsEligibleCore( element );


      lock ( cacheContainer.SyncRoot )
      {
        var cache = cacheContainer.CurrenctVersionCache[this] as Dictionary<IHtmlElement, bool>;

        if ( cache != null )
        {

          bool result;
          if ( cache.TryGetValue( element, out result ) )
            return result;
        }

        else
          cacheContainer.CurrenctVersionCache[this] = cache = new Dictionary<IHtmlElement, bool>();

        return cache[element] = IsEligibleCore( element );

      }
    }

        public TableEntity(IHtmlElement tableElement)
        {
            var head = tableElement.FindFirst("thead");
            this.THead = new THeadEntity(head);

            var headTrList = head.Find("tr");
            foreach (var tr in headTrList)
            {
                var trEntity = new TrEntity(tr);
                var tdList = tr.Find("td").ToList();
                foreach (var td in tdList)
                {
                    trEntity.TdList.Add(new TdEntity(td) { Text = td.InnerText() });
                }
                this.THead.TrList.Add(trEntity);
            }
            var body = tableElement.FindFirst("tbody");
            this.TBody = new TBodyEntity(body);

            var bodyTrList = body.Find("tr");
            foreach (var tr in bodyTrList)
            {
                var trEntity = new TrEntity(tr);
                var tdList = tr.Find("td").ToList();
                foreach (var td in tdList)
                {
                    trEntity.TdList.Add(new TdEntity(td) { Text = td.InnerText() });
                }
                this.TBody.TrList.Add(trEntity);
            }
        }

    bool ISelector.IsEligible( IHtmlElement element )
    {
      if ( element == null )
        return false;

      return _elements.Contains( element );
    }

 private void AddStyleReferences( IHtmlElement headElement, string[] styleFiles )
 {
   foreach ( var path in styleFiles )
     headElement.AddElement( "link" )
       .SetAttribute( "rel", "stylesheet" )
       .SetAttribute( "type", "text/css" )
       .SetAttribute( "href", path );
 }

    /// <summary>
    /// 派生类调用此构造函数初始化 FormTextControl 实例
    /// </summary>
    /// <param name="form">所属表单</param>
    /// <param name="element">定义文本控件的元素</param>
    protected FormTextControl( HtmlForm form, IHtmlElement element )
      : base( form )
    {

      Element = element;
      MaxLength = GetMaxLength();

    }