public void LoadRules()

in Source/RulesEngine/TraceAnalyzer.cs [99:174]
57 lines of code
13 McCabe index (conditional complexity)

        public void LoadRules(TextReader rules)
        {
            using (JsonTextReader reader = new JsonTextReader(rules))
            {
                
                JObject jsonObject = JObject.Load(reader);
                JToken parseToken;

                // Parse the rules from the data
                if (jsonObject.TryGetValue("Rules", out parseToken) == true)
                {
                    var ruleParameters = parseToken as JArray;

                    // Loop over each rule in the array
                    foreach (var ruleDef in ruleParameters)
                    {
                        var ruleName = ruleDef["Type"].ToString();
                        // Using C# reflection look up the rule's type
                        // This way we can just make the rules and not worry about adding it to the RuleEngine
                        // This does require that rules are named in this format: {RuleName}Rule. ie- CallFrequency/Rule/.
                        Type ruleType = Type.GetType("XboxLiveTrace." + ruleName + "Rule");

                        // If the rule isn't a built in rule, check for a custom rule.
                        if(ruleType == null)
                        {
                            var assemblies = AppDomain.CurrentDomain.GetAssemblies();

                            foreach (var assembly in assemblies.Where(a => a.GlobalAssemblyCache == false))
                            {
                                foreach(var type in assembly.GetTypes().Where(t => typeof(IRule).IsAssignableFrom(t)))
                                {
                                    if(type.Name.EndsWith(ruleName))
                                    {
                                        ruleType = type;
                                        break;
                                    }
                                }

                                if(ruleType != null)
                                {
                                    break;
                                }
                            }
                        }

                        // Make sure the type was value
                        if (ruleDef["Type"] != null && ruleType != null)
                        {
                            // Create the rule and cast to Rule
                            IRule rule = Activator.CreateInstance(ruleType) as IRule;

                            // Fill in the data
                            if (ruleDef["Name"] != null)
                            {
                                rule.Name = ruleDef["Name"].ToString();
                            }
                            if (ruleDef["Endpoint"] != null)
                            {
                                rule.Endpoint = ruleDef["Endpoint"].ToString();
                            }
                            if (ruleDef["Properties"] != null)
                            {
                                rule.DeserializeJson(ruleDef["Properties"] as JObject);
                            }

                            m_rules.Add(rule);
                        }
                        else
                        {
                            throw new Exception("Invalid rule type " + ruleDef["Name"] + " in rule definition file.");
                        }

                    }
                }
            }
        }