/// <summary> /// Determines whether the given rule is suppressed for the given element. /// </summary> /// <param name="element"> /// The element to check. /// </param> /// <param name="ruleCheckId"> /// The Id of the rule to check. /// </param> /// <param name="ruleName"> /// The Name of the rule to check. /// </param> /// <param name="ruleNamespace"> /// The Namespace of the rule to check. /// </param> /// <returns> /// Returns true is the rule is suppressed; otherwise false. /// </returns> public override bool IsRuleSuppressed(ICodeElement element, string ruleCheckId, string ruleName, string ruleNamespace) { if (element != null && !string.IsNullOrEmpty(ruleCheckId) && ruleName != string.Empty && !string.IsNullOrEmpty(ruleNamespace)) { SuppressedRule suppressedRule = new SuppressedRule { RuleId = ruleCheckId, RuleName = ruleName, RuleNamespace = ruleNamespace }; this.suppressionsLock.AcquireReaderLock(Timeout.Infinite); try { if (ruleCheckId != "*") { // See if this namespace is suppressed completely. if (this.IsRuleSuppressed(element, "*", null, ruleNamespace)) { return(true); } } List <CsElement> list = null; if ((this.suppressions.Count != 0) && this.suppressions.TryGetValue(suppressedRule, out list)) { return(MatchElementWithPossibleElementsTraversingParents((CsElement)element, list)); } } finally { this.suppressionsLock.ReleaseReaderLock(); } } return(false); }
/// <summary> /// Adds a rule suppression for the given element. /// </summary> /// <param name="element"> /// The element. /// </param> /// <param name="ruleId"> /// The ID of the rule to suppress. /// </param> /// <param name="ruleName"> /// The name of the rule. /// </param> /// <param name="ruleNamespace"> /// The namespace in which the rule is contained. /// </param> internal void AddRuleSuppression(CsElement element, string ruleId, string ruleName, string ruleNamespace) { Param.AssertNotNull(element, "element"); Param.AssertValidString(ruleId, "ruleId"); Param.Assert(ruleId == "*" || !string.IsNullOrEmpty(ruleName), "ruleName", "Rule name is invalid."); Param.AssertValidString(ruleNamespace, "ruleNamespace"); SuppressedRule suppressedRule = new SuppressedRule { RuleId = ruleId, RuleName = ruleName, RuleNamespace = ruleNamespace }; // Need a writer lock arond this entire section to ensure thread safety of dictionary // and the lists contained inside. this.suppressionsLock.AcquireWriterLock(Timeout.Infinite); try { // Determine whether there is already at least one suppression for some element for this rule. List <CsElement> elementsContainingSuppressedRule = null; bool foundElementList = false; if (this.suppressions.Count != 0) { foundElementList = this.suppressions.TryGetValue(suppressedRule, out elementsContainingSuppressedRule); } Debug.Assert( !foundElementList || elementsContainingSuppressedRule != null, "The returned list of elements containing the suppressed rule should never be null."); if (!foundElementList) { // This is the first suppression for this rule type. elementsContainingSuppressedRule = new List <CsElement>(); this.suppressions.Add(suppressedRule, elementsContainingSuppressedRule); } elementsContainingSuppressedRule.Add(element); } finally { this.suppressionsLock.ReleaseWriterLock(); } }
public override bool IsRuleSuppressed(CodeElement element, string ruleCheckId, string ruleName, string ruleNamespace) { if (((element != null) && !string.IsNullOrEmpty(ruleCheckId)) && (!string.IsNullOrEmpty(ruleName) && !string.IsNullOrEmpty(ruleNamespace))) { SuppressedRule key = new SuppressedRule(); key.RuleId = ruleCheckId; key.RuleName = ruleName; key.RuleNamespace = ruleNamespace; this.suppressionsLock.AcquireReaderLock(-1); try { List<CsElement> list = null; if ((this.suppressions.Count != 0) && this.suppressions.TryGetValue(key, out list)) { return MatchElementWithPossibleElementsTraversingParents((CsElement) element, list); } } finally { this.suppressionsLock.ReleaseReaderLock(); } } return false; }
internal void AddRuleSuppression(CsElement element, string ruleId, string ruleName, string ruleNamespace) { SuppressedRule key = new SuppressedRule(); key.RuleId = ruleId; key.RuleName = ruleName; key.RuleNamespace = ruleNamespace; this.suppressionsLock.AcquireWriterLock(-1); try { List<CsElement> list = null; bool flag = false; if (this.suppressions.Count != 0) { flag = this.suppressions.TryGetValue(key, out list); } if (!flag) { list = new List<CsElement>(); this.suppressions.Add(key, list); } list.Add(element); } finally { this.suppressionsLock.ReleaseWriterLock(); } }
/// <summary> /// Adds a rule suppression for the given element. /// </summary> /// <param name="element"> /// The element. /// </param> /// <param name="ruleId"> /// The ID of the rule to suppress. /// </param> /// <param name="ruleName"> /// The name of the rule. /// </param> /// <param name="ruleNamespace"> /// The namespace in which the rule is contained. /// </param> internal void AddRuleSuppression(CsElement element, string ruleId, string ruleName, string ruleNamespace) { Param.AssertNotNull(element, "element"); Param.AssertValidString(ruleId, "ruleId"); Param.Assert(ruleId == "*" || !string.IsNullOrEmpty(ruleName), "ruleName", "Rule name is invalid."); Param.AssertValidString(ruleNamespace, "ruleNamespace"); SuppressedRule suppressedRule = new SuppressedRule { RuleId = ruleId, RuleName = ruleName, RuleNamespace = ruleNamespace }; // Need a writer lock arond this entire section to ensure thread safety of dictionary // and the lists contained inside. this.suppressionsLock.AcquireWriterLock(Timeout.Infinite); try { // Determine whether there is already at least one suppression for some element for this rule. List<CsElement> elementsContainingSuppressedRule = null; bool foundElementList = false; if (this.suppressions.Count != 0) { foundElementList = this.suppressions.TryGetValue(suppressedRule, out elementsContainingSuppressedRule); } Debug.Assert( !foundElementList || elementsContainingSuppressedRule != null, "The returned list of elements containing the suppressed rule should never be null."); if (!foundElementList) { // This is the first suppression for this rule type. elementsContainingSuppressedRule = new List<CsElement>(); this.suppressions.Add(suppressedRule, elementsContainingSuppressedRule); } elementsContainingSuppressedRule.Add(element); } finally { this.suppressionsLock.ReleaseWriterLock(); } }
/// <summary> /// Determines whether the given rule is suppressed for the given element. /// </summary> /// <param name="element"> /// The element to check. /// </param> /// <param name="ruleCheckId"> /// The Id of the rule to check. /// </param> /// <param name="ruleName"> /// The Name of the rule to check. /// </param> /// <param name="ruleNamespace"> /// The Namespace of the rule to check. /// </param> /// <returns> /// Returns true is the rule is suppressed; otherwise false. /// </returns> public override bool IsRuleSuppressed(ICodeElement element, string ruleCheckId, string ruleName, string ruleNamespace) { if (element != null && !string.IsNullOrEmpty(ruleCheckId) && ruleName != string.Empty && !string.IsNullOrEmpty(ruleNamespace)) { SuppressedRule suppressedRule = new SuppressedRule { RuleId = ruleCheckId, RuleName = ruleName, RuleNamespace = ruleNamespace }; this.suppressionsLock.AcquireReaderLock(Timeout.Infinite); try { if (ruleCheckId != "*") { // See if this namespace is suppressed completely. if (this.IsRuleSuppressed(element, "*", null, ruleNamespace)) { return true; } } List<CsElement> list = null; if ((this.suppressions.Count != 0) && this.suppressions.TryGetValue(suppressedRule, out list)) { return MatchElementWithPossibleElementsTraversingParents((CsElement)element, list); } } finally { this.suppressionsLock.ReleaseReaderLock(); } } return false; }