HandCoded.Validation.Rule.ForName C# (CSharp) Метод

        public static Rule ForName(string name)
        {
            return (extent.ContainsKey (name) ? extent [name] : null);
        }

        /// <summary>
        /// Parse the <b>RuleSet</b> definitions in the configuration file
        /// indicated by the URI.
        /// </summary>
        /// <param name="uri">The URI of the business rule configuration file.</param>
        private static void ParseRuleSets(string uri)
        {
            RuleSet   ruleSet = null;
            XmlReader reader  = XmlReader.Create(uri);

            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                {
                    if (reader.LocalName.Equals("forceLoad"))
                    {
                        string platform       = reader ["platform"];
                        string implementation = reader ["class"];

                        if (platform.Equals(".Net"))
                        {
                            try {
                                Type type = Type.GetType(implementation);

                                if (type != null)
                                {
                                    // Access each member to ensure it has a chance to initialise
                                    MemberInfo [] members = type.GetMembers();
                                    if (members != null)
                                    {
                                        foreach (MemberInfo member in members)
                                        {
                                            if (member.MemberType == MemberTypes.Field)
                                            {
                                                type.InvokeMember(member.Name, BindingFlags.GetField, null, null, null);
                                            }
                                        }
                                    }
                                    break;
                                }
                                else
                                {
                                    logger.Error("Could not find load rule class '" + implementation + "'");
                                }
                            }
                            catch (Exception error) {
                                logger.Error("Could not force load rule class '" + implementation + "'", error);
                            }
                        }
                    }
                    else if (reader.LocalName.Equals("ruleSet"))
                    {
                        string name = reader ["name"];

                        ruleSet = new RuleSet(name);
                    }
                    else if (reader.LocalName.Equals("addRule"))
                    {
                        string name = reader ["name"];
                        Rule   rule = Rule.ForName(name);

                        if (rule != null)
                        {
                            if (ruleSet != null)
                            {
                                ruleSet.Add(rule);
                            }
                            else
                            {
                                logger.Error("Syntax error in rule file - addRule outside of RuleSet");
                            }
                        }
                        else
                        {
                            logger.Error("Reference to undefined rule '" + name + "' in addRule");
                        }
                    }
                    else if (reader.LocalName.Equals("removeRule"))
                    {
                        string name = reader ["name"];
                        Rule   rule = Rule.ForName(name);

                        if (rule != null)
                        {
                            if (ruleSet != null)
                            {
                                ruleSet.Remove(rule);
                            }
                            else
                            {
                                logger.Error("Syntax error in rule file - removeRule outside of RuleSet");
                            }
                        }
                        else
                        {
                            logger.Error("Reference to undefined rule '" + name + "' in addRule");
                        }
                    }
                    else if (reader.LocalName.Equals("addRuleSet"))
                    {
                        string  name  = reader ["name"];
                        RuleSet rules = ForName(name);

                        if (rules != null)
                        {
                            if (ruleSet != null)
                            {
                                if (rules != ruleSet)
                                {
                                    ruleSet.Add(rules);
                                }
                                else
                                {
                                    logger.Error("Attempt to recursively define ruleset '" + name + "'");
                                }
                            }
                            else
                            {
                                logger.Error("Syntax error in rule file - addRuleSet outside of RuleSet");
                            }
                        }
                        else
                        {
                            logger.Error("Reference to undefined rule '" + name + "' in addRule");
                        }
                    }
                    break;
                }

                case XmlNodeType.EndElement:
                {
                    if (reader.LocalName.Equals("ruleSet"))
                    {
                        ruleSet = null;
                    }

                    break;
                }
                }
            }
            reader.Close();
        }