Ejemplo n.º 1
0
        internal static IEnumerable <QueryMatchResult> GetMatchingRulesByName(XDocument rulePackXDocument, IEnumerable <string> ruleNameQueries, NameMatchingOptions matchingOption = NameMatchingOptions.InvariantNameOrLocalizedNameMatch, bool ignoreCase = true)
        {
            ArgumentValidator.ThrowIfNull("rulePackXDocument", rulePackXDocument);
            ArgumentValidator.ThrowIfNull("ruleNameQueries", ruleNameQueries);
            ArgumentValidator.ThrowIfInvalidValue <NameMatchingOptions>("matchingOption", matchingOption, (NameMatchingOptions nameMatchingOption) => nameMatchingOption == NameMatchingOptions.InvariantNameMatchOnly || NameMatchingOptions.InvariantNameOrLocalizedNameMatch == nameMatchingOption);
            List <string> ruleNameQueriesList = new List <string>((from query in ruleNameQueries
                                                                   where !string.IsNullOrEmpty(query)
                                                                   select query).OrderBy((string query) => query, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal));

            if (ruleNameQueriesList.Count == 0)
            {
                return(Enumerable.Empty <QueryMatchResult>());
            }
            CultureInfo currentThreadCulture = CultureInfo.CurrentCulture;
            ParallelQuery <QueryMatchResult> parallelQuery;

            if (matchingOption != NameMatchingOptions.InvariantNameMatchOnly)
            {
                parallelQuery = from resourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
                                let queryHitIndex = XmlProcessingUtils.GetInvariantOrLocalizedNameHitIndex(ruleNameQueriesList, resourceElement, currentThreadCulture, ignoreCase)
                                                    where queryHitIndex >= 0
                                                    let ruleIdRef = resourceElement.Attribute("idRef").Value
                                                                    let finalRuleIdRef = string.IsNullOrEmpty(ruleIdRef) ? null : ruleIdRef
                                                                                         select new QueryMatchResult
                {
                    QueryString = ruleNameQueriesList[queryHitIndex],
                    MatchingResourceXElement = resourceElement,
                    MatchingRuleId           = finalRuleIdRef,
                    MatchingRuleXElement     = null
                };
            }
            else
            {
                parallelQuery = from resourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
                                let invariantLocalizedNameDetails = XmlProcessingUtils.ReadDefaultRuleMetadata(resourceElement)
                                                                    let queryHitIndex = ruleNameQueriesList.BinarySearch(invariantLocalizedNameDetails.Name, StringComparer.Create(invariantLocalizedNameDetails.Culture, ignoreCase))
                                                                                        where queryHitIndex >= 0
                                                                                        let ruleIdRef = resourceElement.Attribute("idRef").Value
                                                                                                        let finalRuleIdRef = string.IsNullOrEmpty(ruleIdRef) ? null : ruleIdRef
                                                                                                                             select new QueryMatchResult
                {
                    QueryString = ruleNameQueriesList[queryHitIndex],
                    MatchingResourceXElement = resourceElement,
                    MatchingRuleId           = finalRuleIdRef,
                    MatchingRuleXElement     = null
                };
            }
            ParallelQuery <QueryMatchResult> mainQuery = parallelQuery;

            return(XmlProcessingUtils.ExecuteQueryMatching(mainQuery, (Dictionary <string, QueryMatchResult> queryMatchResultsDictionary) => from ruleElement in rulePackXDocument.Descendants().AsParallel <XElement>()
                                                           where ClassificationDefinitionConstants.MceRuleElementNames.Contains(ruleElement.Name.LocalName)
                                                           let ruleId = (string)ruleElement.Attribute("id")
                                                                        let finalRuleId = string.IsNullOrEmpty(ruleId) ? null : ruleId
                                                                                          where queryMatchResultsDictionary.ContainsKey(finalRuleId)
                                                                                          select new KeyValuePair <string, XElement>(finalRuleId, ruleElement), delegate(Dictionary <string, QueryMatchResult> queryMatchResultsDictionary, KeyValuePair <string, XElement> matchAssociation)
            {
                queryMatchResultsDictionary[matchAssociation.Key].MatchingRuleXElement = matchAssociation.Value;
            }, new Func <string, LocalizedString>(Strings.ClassificationRuleCollectionOrphanedResourceViolation)));
        }
Ejemplo n.º 2
0
        internal static IEnumerable <QueryMatchResult> GetMatchingRulesById(XDocument rulePackXDocument, ISet <string> ruleIdQuerySet = null)
        {
            ArgumentValidator.ThrowIfNull("rulePackXDocument", rulePackXDocument);
            ParallelQuery <QueryMatchResult> parallelQuery;

            if (ruleIdQuerySet != null)
            {
                parallelQuery = from rulePackElement in rulePackXDocument.Descendants().AsParallel <XElement>()
                                where ClassificationDefinitionConstants.MceRuleElementNames.Contains(rulePackElement.Name.LocalName)
                                let ruleId = rulePackElement.Attribute("id").Value
                                             let finalRuleId = string.IsNullOrEmpty(ruleId) ? null : ruleId
                                                               where ruleIdQuerySet.Contains(finalRuleId)
                                                               select new QueryMatchResult
                {
                    QueryString          = finalRuleId,
                    MatchingRuleId       = finalRuleId,
                    MatchingRuleXElement = rulePackElement
                };
            }
            else
            {
                parallelQuery = from rulePackElement in rulePackXDocument.Descendants().AsParallel <XElement>()
                                where ClassificationDefinitionConstants.MceRuleElementNames.Contains(rulePackElement.Name.LocalName)
                                let ruleId = rulePackElement.Attribute("id").Value
                                             let finalRuleId = string.IsNullOrEmpty(ruleId) ? null : ruleId
                                                               select new QueryMatchResult
                {
                    MatchingRuleId       = finalRuleId,
                    MatchingRuleXElement = rulePackElement
                };
            }
            ParallelQuery <QueryMatchResult> mainQuery = parallelQuery;

            return(XmlProcessingUtils.ExecuteQueryMatching(mainQuery, (Dictionary <string, QueryMatchResult> queryMatchResultsDictionary) => from resourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
                                                           let ruleIdRef = (string)resourceElement.Attribute("idRef")
                                                                           where queryMatchResultsDictionary.ContainsKey(ruleIdRef)
                                                                           select new KeyValuePair <string, XElement>(ruleIdRef, resourceElement), delegate(Dictionary <string, QueryMatchResult> queryMatchResultsDictionary, KeyValuePair <string, XElement> matchAssociation)
            {
                queryMatchResultsDictionary[matchAssociation.Key].MatchingResourceXElement = matchAssociation.Value;
            }, new Func <string, LocalizedString>(Strings.ClassificationRuleCollectionResourceNotFoundViolation)));
        }