C# Element.GetAttribute方法代码示例

        /// <summary>
        /// Creates and attaches behaviors specified on the element declaratively.
        /// </summary>
        /// <param name="element">The element whose behaviors should be created and attached.</param>
        private void AttachBehaviors(Element element)
        {
            string[] behaviorNames = ((string)element.GetAttribute(Application.BehaviorsAttribute)).Split(",");
            int behaviorCount = behaviorNames.Length;

            for (int i = 0; i < behaviorCount; i++) {
                string name = behaviorNames[i].Trim();

                BehaviorRegistration registration = _registeredBehaviors[name];
                Debug.Assert(registration != null, "Unknown behavior '" + name + "'");

                if (registration != null) {
                    Dictionary<string, object> options = OptionsParser.GetOptions(element, name);

                    // Use the Application's IoC capabilities to create behaviors.
                    // This allows satisfying dependencies behaviors have to other services,
                    // and also allows behaviors to provide or register services into the container.

                    Behavior behavior = (Behavior)GetObject(registration.BehaviorType);
                    behavior.Initialize(element, options);

                    if (registration.ServiceType != null) {
                        // Special-case the common case where a behavior represents a single
                        // service type, and auto-register it.
                        // In the case where a behavior is registering multiple service types
                        // (not so common), it can do so manually in its Initialize method.

                        RegisterObject(registration.ServiceType, behavior);
                    }
                }
            }
        }

        public static Dictionary<string, object> GetOptions(Element element, string name)
        {
            // Options can be specified using a pseudo-JSON/css-esque syntax
            // as the value of a data-<name> attribute on the element.

            string optionsText = (string)element.GetAttribute("data-" + name);
            if (String.IsNullOrEmpty(optionsText) == false) {
                return Parse(optionsText);
            }
            else {
                // Create an empty object if no options were declaratively specified
                // so that behaviors always get an object instance in the call to
                // Initialize.

                return new Dictionary<string, object>();
            }
        }

        public static Dictionary<string, object> GetOptions(Element element, string name)
        {
            // Options can be specified using a pseudo-JSON/css-esque syntax
            // as the value of a data-<name> attribute on the element.

            string optionsText = (string)element.GetAttribute("data-" + name);
            if (String.IsNullOrEmpty(optionsText) == false) {
                if (optionsText.StartsWith("{")) {
                    // Vanilla JSON object
                    return Json.ParseData<Dictionary<string, object>>(optionsText);
                }

                // Treat it as our pseudo-JSON/CSS-esque syntax which requires a bit of rewriting
                // before it can be parsed as JSON.
                return Parse(optionsText);
            }
            else {
                // Create an empty object if no options were declaratively specified.
                return new Dictionary<string, object>();
            }
        }

        /// <summary>
        /// Construct a Module JS object to wrap the Html.Element representing the DOM element
        /// </summary>
        /// <param name="element"></param>
        public Module(Element element)
        {
            Instances.Add(new ModuleInstance(element, this));

            // store a reference to the JQuery and DOM elements
            this.Element = element;
            this.Obj = jQuery.FromElement(element);

            // This is currently unused code
            this.NeedsData = (string)element.GetAttribute("data-async") == "true";
            if (this.NeedsData)
            {
                this.LoadingElement = Document.CreateElement("div");
                this.LoadingElement.ClassName = "loading";
                this.LoadingElement.InnerHTML = "Loading...";

                jQuery.FromElement(this.LoadingElement).InsertAfter(this.Obj.Find(".data"));

                this.Obj.Find(".data").Hide(0);
                this.LoadData();
            }
        }

        private void SetupBindings(Element element, object model)
        {
            Debug.Assert(element != null);

            string bindings = (string)element.GetAttribute(Application.BindingsAttribute);
            bindings.ReplaceRegex(Application.BindingsRegex, delegate(string match /*, string binderType, string expressionType, string expressionValue */) {
                string binderType = (string)Arguments.GetArgument(1);
                string expressionType = (string)Arguments.GetArgument(2);
                string expressionValue = (string)Arguments.GetArgument(3);

                ExpressionFactory expressionFactory = _registeredExpressions[expressionType];
                Debug.Assert(expressionFactory != null, "Unknown expression of type '" + expressionType + "' found.");

                if (expressionFactory != null) {
                    Expression expression = expressionFactory(model, expressionType, expressionValue);
                    Binder binder = null;

                    // TODO: Add support for binding attributes - @xxx

                    if (binderType.StartsWith("on.")) {
                        Debug.Assert(expression.CanChange == false, "Events cannot be bound to dynamic expressions.");
                        Debug.Assert(expression.GetValue() is Action);

                        binder = new EventBinder(element, binderType.Substr(3), (ElementEventListener)expression.GetValue());
                    }
                    else if (binderType.StartsWith("style.")) {
                        object style = element.Style;
                        binder = new PropertyBinder(style, binderType.Substr(6), expression);
                    }
                    else {
                        BinderFactory binderFactory = _registeredBinders[binderType];
                        if (binderFactory == null) {
                            binder = new PropertyBinder(element, binderType, expression);
                        }
                        else {
                            binder = binderFactory(element, binderType, expression);
                        }
                    }

                    if (binder != null) {
                        binder.Update();
                        if (expression.CanChange == false) {
                            // Since the expression value cannot change, there isn't a whole lot of need
                            // to keep the binder alive and manage it.
                            binder = null;
                        }
                    }

                    if (binder != null) {
                        // The binder is managed using a behavior that is attached to the element.
                        // This allows stashing the model for later retrieval, as well as a way to
                        // dispose bindings (the behavior disposes all binders it is managing).

                        BinderManager binderManager = (BinderManager)Behavior.GetBehavior(element, typeof(BinderManager));
                        if (binderManager == null) {
                            binderManager = new BinderManager();
                            binderManager.Initialize(element, null);
                            binderManager.Model = model;
                        }

                        binderManager.AddBinder(binder);
                    }
                }

                return String.Empty;
            });
        }