C# HtmlElement.Attributes方法代码示例

        public void ReplaceAll(HtmlObject[] content)
        {
            HtmlElement parent = new HtmlElement("parent", new HtmlElement("element"), new HtmlAttribute("attribute1"), new HtmlAttribute("attribute2"), new HtmlComment("comment"));

            parent.ReplaceAll(content);
            Assert.Equal(content.OfType<HtmlElement>().ToArray(), parent.Elements().ToArray());
            Assert.Equal(content.OfType<HtmlAttribute>().ToArray(), parent.Attributes().ToArray());
            Assert.Equal(parent.Elements().Count() + parent.Attributes().Count(), parent.ElementsAndAttributes().Count());
            Assert.Equal(parent.Nodes().Count() + parent.Attributes().Count(), parent.NodesAndAttributes().Count());
        }

 public void Ctor_String_ParamsHtmlObject(HtmlObject[] content)
 {
     HtmlElement element = new HtmlElement("element", content);
     Assert.Equal("element", element.Tag);
     Assert.False(element.IsVoid);
     Assert.Equal(content.OfType<HtmlElement>().ToArray(), element.Elements().ToArray());
     Assert.Equal(content.OfType<HtmlAttribute>().ToArray(), element.Attributes().ToArray());
     Assert.Equal(content.OfType<HtmlNode>().ToArray(), element.Nodes().ToArray());
     Assert.Equal(element.Elements().Count() + element.Attributes().Count(), element.ElementsAndAttributes().Count());
     Assert.Equal(content.Length, element.NodesAndAttributes().Count());
 }

        public IHtmlNode CreateTextArea()
        {
            var element = new HtmlElement(editor.TagName).Attributes(new { name = editor.Name, id = editor.Id });
            var inline = editor.TagName != "textarea";

            if (inline)
            {
                element.Attribute("contentEditable", "true");
            }
            else
            {
                element.Attributes(new
                {
                    cols = "20",
                    rows = "5"
                });
            }

            element.Attributes(editor.GetUnobtrusiveValidationAttributes())
                   .Attributes(editor.HtmlAttributes);

            var value = editor.GetValue<string>(editor.Value);

            if (!string.IsNullOrEmpty(value))
            {
                if (inline)
                {
                    element.Html(value);
                }
                else
                {
                    element.Text(value);
                }
            }
            else if (editor.Content != null)
            {
                editor.Template.Apply(element);
            }
            else if (editor.Template.InlineTemplate != null)
            {
                var html = editor.Template.InlineTemplate(null).ToString();

                if (inline)
                {
                    element.Html(html);
                }
                else
                {
                    element.Text(html);
                }
            }

            return element;
        }

        public void Add_HtmlObject(bool isVoid)
        {
            HtmlElement parent = new HtmlElement("parent", isVoid);

            // Atribute
            HtmlAttribute attribute = new HtmlAttribute("attribute");
            parent.Add(attribute);
            Assert.Equal(parent, attribute.Parent);
            Assert.Equal(new HtmlAttribute[] { attribute }, parent.Attributes());

            if (!isVoid)
            {
                // Element
                HtmlElement element = new HtmlElement("element");
                parent.Add(element);
                Assert.Equal(parent, element.Parent);
                Assert.Equal(new HtmlElement[] { element }, parent.Elements());

                // Nodes
                HtmlComment comment = new HtmlComment("comment");
                parent.Add(comment);
                Assert.Equal(parent, comment.Parent);
                Assert.Equal(new HtmlObject[] { element, comment }, parent.Nodes());
            }
        }

 public void Add_ParamsHtmlObject_Empty()
 {
     HtmlElement element = new HtmlElement("parent");
     element.Add(new HtmlObject[0]);
     Assert.Empty(element.Elements());
     Assert.Empty(element.Attributes());
 }

        public void Apply(IHtmlNode parent)
        {
            var span = new HtmlElement("span");

            span.Attributes(button.ImageHtmlAttributes).AddClass(UIPrimitives.Icon, button.SpriteCssClass);

            span.AppendTo(parent);
        }

 public void Ctor_String(string tag, string expectedTag)
 {
     HtmlElement element = new HtmlElement(tag);
     Assert.Equal(expectedTag, element.Tag);
     Assert.False(element.IsVoid);
     Assert.Empty(element.Elements());
     Assert.Empty(element.Attributes());
     Assert.Empty(element.ElementsAndAttributes());
 }

 public void Ctor_String_Bool(string tag, bool isVoid, string expectedTag)
 {
     HtmlElement element = new HtmlElement(tag, isVoid);
     Assert.Equal(expectedTag, element.Tag);
     Assert.Equal(isVoid, element.IsVoid);
     Assert.Empty(element.Elements());
     Assert.Empty(element.Attributes());
     Assert.Empty(element.ElementsAndAttributes());
 }

        public void ReplaceAll_IEnumerableHtmlObject_AttributeToVoidElement()
        {
            HtmlElement parent = new HtmlElement("parent", isVoid: true);
            parent.Add(new HtmlAttribute("attribute"));

            HtmlAttribute[] attributes = new HtmlAttribute[] { new HtmlAttribute("attribute1"), new HtmlAttribute("attribute2") };
            parent.ReplaceAll((IEnumerable<HtmlObject>)attributes);
            Assert.Equal(attributes, parent.Attributes());
        }

        public void Add_ParamsHtmlObject_VoidElement()
        {
            HtmlElement element = new HtmlElement("parent", isVoid: true);
            HtmlAttribute attribute1 = new HtmlAttribute("attribute1");
            HtmlAttribute attribute2 = new HtmlAttribute("attribute2");
            element.Add(new HtmlObject[] { attribute1, attribute2 });

            Assert.Equal(element, attribute1.Parent);
            Assert.Equal(element, attribute2.Parent);
            Assert.Empty(element.Elements());
            Assert.Equal(new HtmlAttribute[] { attribute1, attribute2 }, element.Attributes());
        }

        protected virtual void CreateFooterElement(IHtmlNode html)
        {
            if (component.Footer.HasValue())
            {
                var dom = new HtmlElement("footer")
                            .Attribute("data-role", "footer");

                component.Footer.Apply(dom);

                dom.Attributes(component.FooterHtmlAttributes);

                html.Children.Add(dom);
            }
        }

        public void Add_ParamsHtmlObject_NonVoidElement()
        {
            HtmlElement parent = new HtmlElement("parent");
            HtmlElement element = new HtmlElement("element");
            HtmlAttribute attribute = new HtmlAttribute("attribute");
            HtmlComment comment = new HtmlComment("comment");
            parent.Add(new HtmlObject[] { element, attribute, comment });

            Assert.Equal(parent, element.Parent);
            Assert.Equal(parent, attribute.Parent);
            Assert.Equal(new HtmlObject[] { element }, parent.Elements());
            Assert.Equal(new HtmlAttribute[] { attribute }, parent.Attributes());
            Assert.Equal(new HtmlObject[] { element, comment }, parent.Nodes());
        }

        public virtual IHtmlNode Create(object dataItem)
        {
            var button = new HtmlElement(ButtonTagName);

            ApplyButtonAttributes(button, dataItem);

            button.Attributes(HtmlAttributes)
                  .AddClass(CssClass);

            foreach (var decorator in Decorators)
            {
                decorator.Apply(button);
            }

            return button;
        }

        public void ReplaceAttributes_ParamsHtmlAttribute_VoidElement()
        {
            HtmlElement parent = new HtmlElement("parent", isVoid: true);
            parent.Add(new HtmlAttribute("attribute"));

            HtmlAttribute[] attributes = new HtmlAttribute[] { new HtmlAttribute("attribute1"), new HtmlAttribute("attribute2") };
            parent.ReplaceAttributes(attributes);
            Assert.Equal(attributes, parent.Attributes());
        }

 public void WithTabIndex()
 {
     HtmlElement element = new HtmlElement("html");
     Assert.Same(element, element.WithTabIndex("value"));
     Assert.Equal(Attribute.TabIndex("value"), element.Attributes().First());
 }