Analyzers.xml

<?xml version="1.0" encoding="utf-8"?>
<Analyzers>
  <Analyzer Identifier="AddBracesWhenExpressionSpansOverMultipleLines">
    <Id>RCS1001</Id>
    <Title>Add braces (when expression spans over multiple lines).</Title>
    <MessageFormat>Add braces to {0} (when expression spans over multiple lines).</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition)
    Foo( // [|Id|]
        x,
        y);]]></Before>
        <After><![CDATA[if (condition)
{
    Foo(
        x,
        y);
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveBraces">
    <Id>RCS1002</Id>
    <Title>Remove braces.</Title>
    <MessageFormat>Remove braces from {0}.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition)
{ // [|Id|]
    Foo();
}]]></Before>
        <After>
          <![CDATA[if (condition)
    Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBracesToIfElseWhenExpressionSpansOverMultipleLines">
    <Id>RCS1003</Id>
    <Title>Add braces to if-else (when expression spans over multiple lines).</Title>
    <MessageFormat>Add braces to if-else (when expression spans over multiple lines).</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition) // [|Id|]
    WhenTrue(
        x,
        y);
else
    WhenFalse(
        x,
        y);]]></Before>
        <After><![CDATA[if (condition)
{
    WhenTrue(
        x,
        y);
}
else
{
    WhenFalse(
        x,
        y);
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveBracesFromIfElse">
    <Id>RCS1004</Id>
    <Title>Remove braces from if-else.</Title>
    <MessageFormat>Remove braces from if-else.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition) // [|Id|]
{
    WhenTrue();
}
else
{
    WhenFalse();
}]]></Before>
        <After><![CDATA[if (condition)
    WhenTrue();
else
    WhenFalse();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyNestedUsingStatement">
    <Id>RCS1005</Id>
    <Title>Simplify nested using statement.</Title>
    <MessageFormat>Simplify nested using statement.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[using (var fs = new FileStream("path", FileMode.OpenOrCreate))
{ // [|Id|]
    using (var sr = new StreamReader(fs))
    {
    }
}]]></Before>
        <After><![CDATA[using (var fs = new FileStream("path", FileMode.OpenOrCreate))
using (var sr = new StreamReader(fs))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MergeElseClauseWithNestedIfStatement">
    <Id>RCS1006</Id>
    <Title>Merge else clause with nested if statement.</Title>
    <MessageFormat>Merge else clause with nested if statement.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition1)
{
    Foo1();
}
else
{ // [|Id|]
    if (condition2)
    {
        Foo2();
    }
}]]></Before>
        <After><![CDATA[if (condition1)
{
    Foo1();
}
else if (condition2)
{
    Foo2();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBraces">
    <Id>RCS1007</Id>
    <Title>Add braces.</Title>
    <MessageFormat>Add braces to {0}.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition)
    Foo(); // [|Id|]]]></Before>
        <After><![CDATA[if (condition)
{
    Foo();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseExplicitTypeInsteadOfVarWhenTypeIsNotObvious">
    <Id>RCS1008</Id>
    <Title>Use explicit type instead of 'var' (when the type is not obvious).</Title>
    <MessageFormat>Use explicit type instead of 'var'.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var s = GetValue(); // [|Id|]]]></Before>
        <After><![CDATA[string s = GetValue();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseExplicitTypeInsteadOfVarInForEach">
    <Id>RCS1009</Id>
    <Title>Use explicit type instead of 'var' (foreach variable).</Title>
    <MessageFormat>Use explicit type instead of 'var'.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var items = new List<string>();

// ...

foreach (var item in items) // [|Id|]
{
}]]></Before>
        <After><![CDATA[foreach (string item in items)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseVarInsteadOfExplicitTypeWhenTypeIsObvious">
    <Id>RCS1010</Id>
    <Title>Use 'var' instead of explicit type (when the type is obvious).</Title>
    <MessageFormat>Use 'var' instead of explicit type.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[Foo foo = new Foo(); // [|Id|]]]></Before>
        <After><![CDATA[var foo = new Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseExplicitTypeInsteadOfVarWhenTypeIsObvious">
    <Id>RCS1012</Id>
    <Title>Use explicit type instead of 'var' (when the type is obvious).</Title>
    <MessageFormat>Use explicit type instead of 'var'.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var foo = new Foo(); // [|Id|]]]></Before>
        <After><![CDATA[Foo foo = new Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UsePredefinedType">
    <Id>RCS1013</Id>
    <Title>Use predefined type.</Title>
    <MessageFormat>Use predefined type.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[String s = null; // [|Id|]]]></Before>
        <After><![CDATA[string s = null;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidImplicitlyTypedArray">
    <Id>RCS1014</Id>
    <Title>Avoid implicitly-typed array.</Title>
    <MessageFormat>Declare explicit type when creating an array.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var items = new[] { "" }; // [|Id|]]]></Before>
        <After><![CDATA[var items = new string[] { "" };]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseNameOfOperator">
    <Id>RCS1015</Id>
    <Title>Use nameof operator.</Title>
    <MessageFormat>Use nameof operator.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>6.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[public void Foo(object parameter)
{
    if (parameter == null)
    {
        throw new ArgumentNullException("parameter", "message"); // [|Id|]
    }
}]]></Before>
        <After>
          <![CDATA[public void Foo(object parameter)
{
    if (parameter == null)
    {
        throw new ArgumentNullException(nameof(parameter), "message");
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseExpressionBodiedMember">
    <Id>RCS1016</Id>
    <Title>Use expression-bodied member.</Title>
    <MessageFormat>Use expression bodied member.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>6.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[public object Foo()
{ // [|Id|]
    return null;
}]]></Before>
        <After><![CDATA[public object Foo() => null;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidMultilineExpressionBody">
    <Id>RCS1017</Id>
    <Title>Avoid multiline expression body.</Title>
    <MessageFormat>Expand expression body with multiline expression.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public string[] Foo() => new string[] // [|Id|]
{
    "a",
    "b",
    "c"
};]]></Before>
        <After><![CDATA[public string[] Foo()
{
    return new string[]
    {
        "a",
        "b",
        "c"
    };
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddAccessibilityModifiers">
    <Id>RCS1018</Id>
    <Title>Add accessibility modifiers.</Title>
    <MessageFormat>Add accessibility modifiers.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[class Foo // [|Id|]
{
    void Bar() // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[internal class Foo
{
    private void Bar()
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OrderModifiers">
    <Id>RCS1019</Id>
    <Title>Order modifiers.</Title>
    <MessageFormat>Order modifiers.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private readonly static object _f; // [|Id|]

internal protected class Foo // [|Id|]
{
}]]></Before>
        <After><![CDATA[private static readonly object _f;

protected internal class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyNullableOfT">
    <Id>RCS1020</Id>
    <Title>Simplify Nullable&lt;T&gt; to T?.</Title>
    <MessageFormat>Simplify Nullable&lt;T&gt; to T?.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[Nullable<int> x = null; // [|Id|]]]></Before>
        <After><![CDATA[int? x = null;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyLambdaExpression">
    <Id>RCS1021</Id>
    <Title>Simplify lambda expression.</Title>
    <MessageFormat>Simplify lambda expression.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = items.Select(f =>
{ // [|Id|]
    return f.ToString();
});]]></Before>
        <After><![CDATA[var x = items.Select(f => f.ToString());]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyLambdaExpressionParameterList" IsObsolete="true">
    <Id>RCS1022</Id>
    <Title>Simplify lambda expression parameter list.</Title>
    <MessageFormat>Simplify lambda expression parameter list.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="FormatEmptyBlock">
    <Id>RCS1023</Id>
    <Title>Format empty block.</Title>
    <MessageFormat>Format empty block.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[void Foo()
{ } // [|Id|]]]></Before>
        <After><![CDATA[void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatAccessorList">
    <Id>RCS1024</Id>
    <Title>Format accessor list.</Title>
    <MessageFormat>Format accessor list.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string Foo { get { return _foo; } set { _foo = value; } } // [|Id|]]]></Before>
        <After>
          <![CDATA[string Foo
{
    get { return _foo; }
    set { _foo = value; }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineBeforeEnumMember">
    <Id>RCS1025</Id>
    <Title>Add new line before enum member.</Title>
    <MessageFormat>Add new line before enum member.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[enum Foo { A, B, C, } // [|Id|]]]></Before>
        <After><![CDATA[enum Foo
{
    A,
    B,
    C,
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineBeforeStatement">
    <Id>RCS1026</Id>
    <Title>Add new line before statement.</Title>
    <MessageFormat>Add new line before statement.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[Foo(); Bar(); // [|Id|]]]></Before>
        <After><![CDATA[Foo();
Bar();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineBeforeEmbeddedStatement">
    <Id>RCS1027</Id>
    <Title>Add new line before embedded statement.</Title>
    <MessageFormat>Add new line before embedded statement.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x) Foo(); // [|Id|]]]></Before>
        <After><![CDATA[if (x)
{
    Foo();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddNewLineAfterSwitchLabel">
    <Id>RCS1028</Id>
    <Title>Add new line after switch label.</Title>
    <MessageFormat>Add new line after switch label.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (x)
{
    case "a": return Foo(); // [|Id|]
    case "b": return Bar();
}]]></Before>
        <After><![CDATA[switch (x)
{
    case "a":
        return Foo();
    case "b":
        return Bar();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatBinaryOperatorOnNextLine">
    <Id>RCS1029</Id>
    <Title>Format binary operator on next line.</Title>
    <MessageFormat>Format binary operator on next line.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x && // [|Id|]
    y &&
    z)
{
}]]></Before>
        <After><![CDATA[if (x
    && y
    && z)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddEmptyLineAfterEmbeddedStatement">
    <Id>RCS1030</Id>
    <Title>Add empty line after embedded statement.</Title>
    <MessageFormat>Add empty line after embedded statement.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x)
    Foo(); // [|Id|]
Bar();]]></Before>
        <After><![CDATA[if (x)
    Foo();

Bar();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveUnnecessaryBraces">
    <Id>RCS1031</Id>
    <Title>Remove unnecessary braces.</Title>
    <MessageFormat>Remove unnecessary braces.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[]]></Before>
        <After><![CDATA[]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantParentheses">
    <Id>RCS1032</Id>
    <Title>Remove redundant parentheses.</Title>
    <MessageFormat>Remove redundant parentheses.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if ((x)) // [|Id|]
{
    return (y); // [|Id|]
}]]></Before>
        <After><![CDATA[if (x)
{
    return y;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantBooleanLiteral">
    <Id>RCS1033</Id>
    <Title>Remove redundant boolean literal.</Title>
    <MessageFormat>Remove redundant '{0}'.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (f == true) // [|Id|]
{
}

if (f != false) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (f)
{
}

if (f)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantSealedModifier">
    <Id>RCS1034</Id>
    <Title>Remove redundant 'sealed' modifier.</Title>
    <MessageFormat>Remove redundant 'sealed' modifier.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[public sealed class Foo
{
    public sealed override string ToString() // [|Id|]
    {
        return "";
    }
}]]></Before>
        <After><![CDATA[public override string ToString()
{
    return "";
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantCommaInInitializer">
    <Id>RCS1035</Id>
    <Title>Remove redundant comma in initializer.</Title>
    <MessageFormat>Remove redundant comma in initializer.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public void Foo()
{
    var arr = new string[] { "a", "b", "c", }; // [|Id|]
}]]></Before>
        <After><![CDATA[public void Foo()
{
    var arr = new string[] { "a", "b", "c" };
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantEmptyLine">
    <Id>RCS1036</Id>
    <Title>Remove redundant empty line.</Title>
    <MessageFormat>Remove redundant empty line.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{

    private string _f;


    public bool Bar()
    {

        return false;

    }

}]]></Before>
        <After><![CDATA[public class Foo
{
    private string _f;

    public bool Bar()
    {
        return false;
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveTrailingWhitespace">
    <Id>RCS1037</Id>
    <Title>Remove trailing white-space.</Title>
    <MessageFormat>Remove trailing white-space.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyStatement">
    <Id>RCS1038</Id>
    <Title>Remove empty statement.</Title>
    <MessageFormat>Remove empty statement.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public void Foo()
{
    ; // [|Id|]
}]]></Before>
        <After><![CDATA[public void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveArgumentListFromAttribute">
    <Id>RCS1039</Id>
    <Title>Remove argument list from attribute.</Title>
    <MessageFormat>Remove argument list from attribute.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[[Obsolete()] // [|Id|]
public void Foo()
{
}]]></Before>
        <After><![CDATA[[Obsolete]
public void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyElseClause">
    <Id>RCS1040</Id>
    <Title>Remove empty else clause.</Title>
    <MessageFormat>Remove empty else clause.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition)
{
    Foo();
}
else // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (condition)
{
    Foo();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyInitializer">
    <Id>RCS1041</Id>
    <Title>Remove empty initializer.</Title>
    <MessageFormat>Remove empty initializer.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var items = new List<object>() { }; // [|Id|]]]></Before>
        <After><![CDATA[var items = new List<object>();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEnumDefaultUnderlyingType">
    <Id>RCS1042</Id>
    <Title>Remove enum default underlying type.</Title>
    <MessageFormat>Remove enum default underlying type.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public enum Foo : int // [|Id|]
{
}]]></Before>
        <After><![CDATA[public enum Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemovePartialModifierFromTypeWithSinglePart">
    <Id>RCS1043</Id>
    <Title>Remove 'partial' modifier from type with a single part.</Title>
    <MessageFormat>Remove 'partial' modifier from type with a single part.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public partial class Foo // [|Id|]
{
}]]></Before>
        <After><![CDATA[public class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveOriginalExceptionFromThrowStatement">
    <Id>RCS1044</Id>
    <Title>Remove original exception from throw statement.</Title>
    <MessageFormat>Remove original exception from throw statement.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[try
{
    Foo();
}
catch (Exception ex)
{
    throw ex; // [|Id|]
}]]></Before>
        <After><![CDATA[try
{
    Foo();
}
catch (Exception ex)
{
    throw;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RenamePrivateFieldAccordingToCamelCaseWithUnderscore">
    <Id>RCS1045</Id>
    <Title>Rename private field according to camel case with underscore.</Title>
    <MessageFormat>Rename private field to camel case with underscore.</MessageFormat>
    <Category>Naming</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private string f; // [|Id|]]]></Before>
        <After><![CDATA[private string _f;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AsynchronousMethodNameShouldEndWithAsync">
    <Id>RCS1046</Id>
    <Title>Asynchronous method name should end with 'Async'.</Title>
    <MessageFormat>Add suffix 'Async' to asynchronous method name.</MessageFormat>
    <Category>Naming</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public static async Task<bool> Foo() // [|Id|]
{
    return await Task.FromResult(false);
}]]></Before>
        <After><![CDATA[public static async Task<bool> FooAsync()
{
    return await Task.FromResult(false);
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="NonAsynchronousMethodNameShouldNotEndWithAsync">
    <Id>RCS1047</Id>
    <Title>Non-asynchronous method name should not end with 'Async'.</Title>
    <MessageFormat>Remove suffix 'Async' from non-asynchronous method name.</MessageFormat>
    <Category>Naming</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public void FooAsync() // [|Id|]
{
}]]></Before>
        <After>
          <![CDATA[public void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseLambdaExpressionInsteadOfAnonymousMethod">
    <Id>RCS1048</Id>
    <Title>Use lambda expression instead of anonymous method.</Title>
    <MessageFormat>Use lambda expression instead of anonymous method.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = items.Select(delegate (object f) // [|Id|]
{
    return f.ToString();
});]]></Before>
        <After><![CDATA[var x = items.Select((object f) =>
{
    return f.ToString();
});]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyBooleanComparison">
    <Id>RCS1049</Id>
    <Title>Simplify boolean comparison.</Title>
    <MessageFormat>Simplify boolean comparison.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[bool f = false;

// ...

if (f == false) // [|Id|]
{
}

if (f != true) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (!f)
{
}

if (!f)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddArgumentListToObjectCreation">
    <Id>RCS1050</Id>
    <Title>Add argument list to object creation expression.</Title>
    <MessageFormat>Add argument list to object creation expression.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var items = new List<string> { "a", "b", "c"  }; // [|Id|]]]></Before>
        <After><![CDATA[var items = new List<string>() { "a", "b", "c"  };]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ParenthesizeConditionInConditionalExpression">
    <Id>RCS1051</Id>
    <Title>Parenthesize condition in conditional expression.</Title>
    <MessageFormat>Parenthesize condition in conditional expression.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[object x = condition ? WhenTrue() : WhenFalse(); // [|Id|]]]></Before>
        <After><![CDATA[object x = (condition) ? WhenTrue() : WhenFalse();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DeclareEachAttributeSeparately">
    <Id>RCS1052</Id>
    <Title>Declare each attribute separately.</Title>
    <MessageFormat>Declare each attribute separately.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[[Obsolete, Conditional("DEBUG")] // [|Id|]
public void Foo()
{
}]]></Before>
        <After><![CDATA[[Obsolete]
[Conditional("DEBUG")]
public void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ReplaceForEachWithFor" IsObsolete="true">
    <Id>RCS1053</Id>
    <Title>Replace foreach statement with for statement.</Title>
    <MessageFormat>Replace foreach statement with for statement.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="MergeLocalDeclarationWithReturnStatement" IsObsolete="true">
    <Id>RCS1054</Id>
    <Title>Merge local declaration with return statement.</Title>
    <MessageFormat>Merge local declaration with return statement.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AvoidSemicolonAtEndOfDeclaration">
    <Id>RCS1055</Id>
    <Title>Avoid semicolon at the end of declaration.</Title>
    <MessageFormat>Remove semicolon from the end of declaration.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
}; // [|Id|]]]></Before>
        <After><![CDATA[public class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidUsageOfUsingAliasDirective">
    <Id>RCS1056</Id>
    <Title>Avoid usage of using alias directive.</Title>
    <MessageFormat>Avoid usage of using alias directive.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[using S = System.String; // [|Id|]

public class Foo
{
    public void Bar()
    {
        string s = S.Empty;
    }
}]]></Before>
        <After><![CDATA[public class Foo
{
    public void Bar()
    {
        string s = System.String.Empty;
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddEmptyLineBetweenDeclarations">
    <Id>RCS1057</Id>
    <Title>Add empty line between declarations.</Title>
    <MessageFormat>Add empty line between declarations.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
      <![CDATA[class Foo
{
    void M1()
    {
    } // [|Id|]
    void M2()
    {
    } // [|Id|]
    /// <summary>
    /// ...
    /// </summary>
    void M3()
    {
    } // [|Id|]
    string P1 { get; set; } // [|Id|]
    [Obsolete]
    string P2 { get; set; }
} // [|Id|]
enum Bar
{
    A = 0, // [|Id|]
    /// <summary>
    /// ...
    /// </summary>
    B = 1, // [|Id|]
    [Obsolete]
    C = 2,
}]]></Before>
        <After><![CDATA[class Foo
{
    void M1()
    {
    }

    void M2()
    {
    }

    /// <summary>
    /// ...
    /// </summary>
    void M3()
    {
    }

    string P1 { get; set; }

    [Obsolete]
    string P2 { get; set; }
}

enum Bar
{
    A = 0,

    /// <summary>
    /// ...
    /// </summary>
    B = 1,

    [Obsolete]
    C = 2,
}]]></After>
      </Sample>
    </Samples>
    <Remarks>This analyzer does not enforce an empty line between two single-line declaration.</Remarks>
  </Analyzer>
  <Analyzer Identifier="UseCompoundAssignment">
    <Id>RCS1058</Id>
    <Title>Use compound assignment.</Title>
    <MessageFormat>Use compound assignment.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[i = i + 2; // [|Id|]]]></Before>
        <After><![CDATA[i += 2;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidLockingOnPubliclyAccessibleInstance">
    <Id>RCS1059</Id>
    <Title>Avoid locking on publicly accessible instance.</Title>
    <MessageFormat>Lock on private field instead of locking on '{0}'.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public void Foo()
{
    lock (this) // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[private readonly object _lockObject = new object();

public void Foo()
{
    lock (_lockObject)
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DeclareEachTypeInSeparateFile">
    <Id>RCS1060</Id>
    <Title>Declare each type in separate file.</Title>
    <MessageFormat>Declare each type in separate file.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo // [|Id|]
{
}

public class Bar
{
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MergeIfStatementWithNestedIfStatement">
    <Id>RCS1061</Id>
    <Title>Merge if statement with nested if statement.</Title>
    <MessageFormat>Merge if statement with nested if statement.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition) // [|Id|]
{
    if (condition2)
    {
    }
}]]></Before>
        <After><![CDATA[if (condition && condition2)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidInterpolatedStringWithNoInterpolation">
    <Id>RCS1062</Id>
    <Title>Avoid interpolated string with no interpolation.</Title>
    <MessageFormat>Remove '$' from interpolated string with no interpolation.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = $""; // [|Id|]]]></Before>
        <After><![CDATA[string s = "";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidUsageOfDoStatementToCreateInfiniteLoop">
    <Id>RCS1063</Id>
    <Title>Avoid usage of do statement to create an infinite loop.</Title>
    <MessageFormat>Use while statement to create an infinite loop.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[do // [|Id|]
{
    // ...
}
while (true);]]></Before>
        <After><![CDATA[while (true)
{
    // ...
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidUsageOfForStatementToCreateInfiniteLoop">
    <Id>RCS1064</Id>
    <Title>Avoid usage of for statement to create an infinite loop.</Title>
    <MessageFormat>Use while statement to create an infinite loop.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[for (;;) // [|Id|]
{
}]]></Before>
        <After><![CDATA[while (true)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidUsageOfWhileStatementToCreateInfiniteLoop">
    <Id>RCS1065</Id>
    <Title>Avoid usage of while statement to create an inifinite loop.</Title>
    <MessageFormat>Use for statement to create an infinite loop.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[while (true) // [|Id|]
{
}]]></Before>
        <After><![CDATA[for (;;)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyFinallyClause">
    <Id>RCS1066</Id>
    <Title>Remove empty finally clause.</Title>
    <MessageFormat>Remove empty finally clause.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[try
{
    Foo();
}
catch (Exception ex)
{
}
finally // [|Id|]
{
}]]></Before>
        <After><![CDATA[try
{
    Foo();
}
catch (Exception ex)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveArgumentListFromObjectCreation">
    <Id>RCS1067</Id>
    <Title>Remove argument list from object creation expression.</Title>
    <MessageFormat>Remove argument list from object creation expression.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var items = new List<string>() { "a", "b", "c" }; // [|Id|]]]></Before>
        <After><![CDATA[var items = new List<string> { "a", "b", "c" };]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyLogicalNegation">
    <Id>RCS1068</Id>
    <Title>Simplify logical negation.</Title>
    <MessageFormat>Simplify logical negation.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[bool f = !true; // [|Id|]]]></Before>
        <After><![CDATA[bool f = false;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool f = !!f2; // [|Id|]]]></Before>
        <After><![CDATA[bool f = f2;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool f = !items.Any(s => !string.IsNullOrEmpty(s)); // [|Id|]]]></Before>
        <After><![CDATA[bool f = items.All(s => string.IsNullOrEmpty(s));]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveUnnecessaryCaseLabel">
    <Id>RCS1069</Id>
    <Title>Remove unnecessary case label.</Title>
    <MessageFormat>Remove unnecessary case label.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (s)
{
    case "a":
        return true;
    case "b": // [|Id|]
    default:
        return false;
}]]></Before>
        <After><![CDATA[switch (s)
{
    case "a":
        return true;
    default:
        return false;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantDefaultSwitchSection">
    <Id>RCS1070</Id>
    <Title>Remove redundant default switch section.</Title>
    <MessageFormat>Remove redundant default switch section.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (s)
{
    case "a":
        return true;
    case "b":
        return false;
    default: // [|Id|]
        break;
}]]></Before>
        <After><![CDATA[switch (s)
{
    case "a":
        return true;
    case "b":
        return false;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantBaseConstructorCall">
    <Id>RCS1071</Id>
    <Title>Remove redundant base constructor call.</Title>
    <MessageFormat>Remove redundant base constructor call.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
    public Foo() : base() // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public class Foo
{
    public Foo()
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyNamespaceDeclaration">
    <Id>RCS1072</Id>
    <Title>Remove empty namespace declaration.</Title>
    <MessageFormat>Remove empty namespace declaration.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[namespace Foo // [|Id|]
{
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ConvertIfToReturnStatement">
    <Id>RCS1073</Id>
    <Title>Convert 'if' to 'return' statement.</Title>
    <MessageFormat>Convert 'if' to 'return' statement.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x) // [|Id|]
{
    return true;
}
else
{
    return false;
}]]></Before>
        <After><![CDATA[return x;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (x != null) // [|Id|]
{
    return x;
}
else
{
    return null;
}]]></Before>
        <After><![CDATA[return x;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantConstructor">
    <Id>RCS1074</Id>
    <Title>Remove redundant constructor.</Title>
    <MessageFormat>Remove redundant constructor.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
    public Foo() // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidEmptyCatchClauseThatCatchesSystemException">
    <Id>RCS1075</Id>
    <Title>Avoid empty catch clause that catches System.Exception.</Title>
    <MessageFormat>Avoid empty catch clause that catches System.Exception.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[try
{
    Foo();
}
catch (Exception ex) // [|Id|]
{
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatDeclarationBraces">
    <Id>RCS1076</Id>
    <Title>Format declaration braces.</Title>
    <MessageFormat>Format declaration braces.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[interface IFoo
{ } // [|Id|]]]></Before>
        <After>
          <![CDATA[interface IFoo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OptimizeLinqMethodCall">
    <Id>RCS1077</Id>
    <Title>Optimize LINQ method call.</Title>
    <MessageFormat>Optimize LINQ method call.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[bool any = items.Where(predicate).Any(); // [|Id|]]]></Before>
        <After><![CDATA[bool any = items.Any(predicate);]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[int max = items.Select(selector).Max(); // [|Id|]]]></Before>
        <After><![CDATA[int max = items.Max(selector);]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[IEnumerable<Foo> x = items.Where(f => f is Foo).Cast<Foo>(); // [|Id|]]]></Before>
        <After><![CDATA[IEnumerable<Foo> x = items.OfType<Foo>();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool x = items.Where((f) => Foo1(f)).Any(f => Foo2(f)); // [|Id|]]]></Before>
        <After><![CDATA[bool x = items.Any((f) => Foo1(f) && Foo2(f));]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[IEnumerable<object> x = items.Select(f => (object)f); // [|Id|]]]></Before>
        <After><![CDATA[IEnumerable<object> x = items.Cast<object>();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool x = items.FirstOrDefault((f) => Foo(f)) != null; // [|Id|]]]></Before>
        <After><![CDATA[bool x = items.Any((f) => Foo(f));]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool x = items.FirstOrDefault() != null; // [|Id|]]]></Before>
        <After><![CDATA[bool x = items.Any();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[var x = list.ElementAt(1); // [|Id|]]]></Before>
        <After><![CDATA[var x = list[1];]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[var x = list.First(); // [|Id|]]]></Before>
        <After><![CDATA[var x = list[0];]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (enumerable.Count() != 0) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (enumerable.Any())
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (list.Count() == 1) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (list.Count == 1)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[var stack = new Stack<object>();
// ...
object x = stack.First(); // [|Id|]]]></Before>
        <After><![CDATA[var stack = new Stack<object>();
// ...
object x = items.Peek();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[var queue = new Queue<object>();
// ...
object x = stack.First(); // [|Id|]]]></Before>
        <After><![CDATA[var queue = new Queue<object>();
// ...
object x = items.Peek();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[enumerable.Any() ? enumerable.First() : default // [|Id|]]]></Before>
        <After><![CDATA[enumerable.FirstOrDefault()]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseEmptyStringLiteralInsteadOfStringEmpty">
    <Id>RCS1078</Id>
    <Title>Use "" instead of string.Empty.</Title>
    <MessageFormat>Use "" instead of string.Empty</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = string.Empty; // [|Id|]]]></Before>
        <After><![CDATA[string s = "";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ThrowingOfNewNotImplementedException">
    <Id>RCS1079</Id>
    <Title>Throwing of new NotImplementedException.</Title>
    <MessageFormat>Implement the functionality instead of throwing new NotImplementedException.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public void Foo()
{
    throw new NotImplementedException(); // [|Id|]
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCountOrLengthPropertyInsteadOfAnyMethod">
    <Id>RCS1080</Id>
    <Title>Use 'Count/Length' property instead of 'Any' method.</Title>
    <MessageFormat>Use '{0}' property instead of 'Any' method.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (list.Any()) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (list.Count > 0)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SplitVariableDeclaration">
    <Id>RCS1081</Id>
    <Title>Split variable declaration.</Title>
    <MessageFormat>Split variable declaration.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private string s, s2; // [|Id|]]]></Before>
        <After><![CDATA[private string s;
private string s2;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCountOrLengthPropertyInsteadOfCountMethod" IsObsolete="true">
    <Id>RCS1082</Id>
    <Title>Use 'Count/Length' property instead of 'Count' method.</Title>
    <MessageFormat>Use '{0}' property instead of 'Count' method.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (list.Count() == 1) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (list.Count == 1)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallAnyInsteadOfCount" IsObsolete="true">
    <Id>RCS1083</Id>
    <Title>Call 'Enumerable.Any' instead of 'Enumerable.Count'.</Title>
    <MessageFormat>Call 'Enumerable.Any' instead of 'Enumerable.Count'.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (enumerable.Count() == 0) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (!enumerable.Any())
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCoalesceExpressionInsteadOfConditionalExpression">
    <Id>RCS1084</Id>
    <Title>Use coalesce expression instead of conditional expression.</Title>
    <MessageFormat>Use coalesce expression instead of conditional expression.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string x = (s != null) ? s : ""; // [|Id|]]]></Before>
        <After><![CDATA[string x = s ?? "";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseAutoProperty">
    <Id>RCS1085</Id>
    <Title>Use auto-implemented property.</Title>
    <MessageFormat>Use auto-implemented property.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private string _foo;

public string Foo // [|Id|]
{
    get { return _foo; }
    set { _foo = value; }
}]]></Before>
        <After><![CDATA[public string Foo { get; set; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseLinefeedAsNewLine">
    <Id>RCS1086</Id>
    <Title>Use linefeed as newline.</Title>
    <MessageFormat>Use linefeed as newline.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="UseCarriageReturnAndLinefeedAsNewLine">
    <Id>RCS1087</Id>
    <Title>Use carriage return + linefeed as newline.</Title>
    <MessageFormat>Use carriage return + linefeed as newline.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="UseSpacesInsteadOfTab">
    <Id>RCS1088</Id>
    <Title>Use space(s) instead of tab.</Title>
    <MessageFormat>Use space(s) instead of tab.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="UsePostfixUnaryOperatorInsteadOfAssignment">
    <Id>RCS1089</Id>
    <Title>Use --/++ operator instead of assignment.</Title>
    <MessageFormat>Use {0} operator instead of assignment.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[i = i + 1; // [|Id|]]]></Before>
        <After><![CDATA[i++;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallConfigureAwait">
    <Id>RCS1090</Id>
    <Title>Call 'ConfigureAwait(false)'.</Title>
    <MessageFormat>Call 'ConfigureAwait(false).</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[public async Task FooAsync()
{
    await GetValueAsync(); // [|Id|]
}]]></Before>
        <After><![CDATA[public async Task FooAsync()
{
    await GetValueAsync().ConfigureAwait(false);
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyRegion">
    <Id>RCS1091</Id>
    <Title>Remove empty region.</Title>
    <MessageFormat>Remove empty region.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[#region Region // [|Id|]
            
#endregion]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddEmptyLineBeforeWhileInDoStatement">
    <Id>RCS1092</Id>
    <Title>Add empty line before 'while' keyword in 'do' statement.</Title>
    <MessageFormat>Add empty line before 'while' keyword in 'do' statement.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[do
{
    Foo(); // [|Id|]
} while (x);]]></Before>
        <After><![CDATA[do
{
    Foo();

} while (x);]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveFileWithNoCode">
    <Id>RCS1093</Id>
    <Title>Remove file with no code.</Title>
    <MessageFormat>Remove file with no code.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="DeclareUsingDirectiveOnTopLevel">
    <Id>RCS1094</Id>
    <Title>Declare using directive on top level.</Title>
    <MessageFormat>Declare using directive on top level.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[namespace Foo
{
    using System; // [|Id|]
}]]></Before>
        <After><![CDATA[using System;

namespace Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCSharp6DictionaryInitializer" IsObsolete="true">
    <Id>RCS1095</Id>
    <Title>Use C# 6.0 dictionary initializer.</Title>
    <MessageFormat>Use C# 6.0 dictionary initializer.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="UseBitwiseOperationInsteadOfCallingHasFlag">
    <Id>RCS1096</Id>
    <Title>Use bitwise operation instead of calling 'HasFlag'.</Title>
    <MessageFormat>Use bitwise operation instead of calling 'HasFlag'.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (options.HasFlag(RegexOptions.IgnoreCase)) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if ((options & RegexOptions.IgnoreCase) != 0)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantToStringCall">
    <Id>RCS1097</Id>
    <Title>Remove redundant 'ToString' call.</Title>
    <MessageFormat>Remove redundant 'ToString' call.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string x = s.ToString(); // [|Id|]]]></Before>
        <After><![CDATA[string x = s;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[string x = $"{s.ToString()}"; // [|Id|]]]></Before>
        <After><![CDATA[string x = $"{s}";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidNullLiteralExpressionOnLeftSideOfBinaryExpression">
    <Id>RCS1098</Id>
    <Title>Avoid 'null' on the left side of a binary expression.</Title>
    <MessageFormat>'null' should be on the right side of a binary expression.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (null == x) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x == null)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DefaultLabelShouldBeLastLabelInSwitchSection">
    <Id>RCS1099</Id>
    <Title>Default label should be the last label in a switch section.</Title>
    <MessageFormat>Move default label to the last position in a switch section.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (s)
{
    default: // [|Id|]
    case "a":
    case "b":
        break;
}]]></Before>
        <After><![CDATA[switch (s)
{
    case "b":
    case "a":
    default:
        break;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatDocumentationSummaryOnSingleLine">
    <Id>RCS1100</Id>
    <Title>Format documentation summary on a single line.</Title>
    <MessageFormat>Format documentation summary on a single line.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <summary> // [|Id|]
/// ...
/// </summary>
public void Foo()
{
}]]></Before>
        <After><![CDATA[/// <summary>...</summary>
public void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatDocumentationSummaryOnMultipleLines">
    <Id>RCS1101</Id>
    <Title>Format documentation summary on multiple lines.</Title>
    <MessageFormat>Format documentation summary on multiple lines.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <summary>...</summary> // [|Id|]
public void Foo()
{
}]]></Before>
        <After><![CDATA[/// <summary>
/// ...
/// </summary>
public void Foo()
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MakeClassStatic">
    <Id>RCS1102</Id>
    <Title>Make class static.</Title>
    <MessageFormat>Make class static.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo // [|Id|]
{
    private static string _f;

    public static void Bar()
    {
    }
}]]></Before>
        <After><![CDATA[public static class Foo
{
    private static string _f;

    public static void Bar()
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ConvertIfToAssignment">
    <Id>RCS1103</Id>
    <Title>Convert 'if' to assignment.</Title>
    <MessageFormat>Convert 'if' to assignment.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition) // [|Id|]
{
    f = true;
}
else
{
    f = false;
}]]></Before>
        <After><![CDATA[f = condition;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (x != null) // [|Id|]
{
    y = x;
}
else
{
    y = null;
}]]></Before>
        <After><![CDATA[y = x;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyConditionalExpression">
    <Id>RCS1104</Id>
    <Title>Simplify conditional expression.</Title>
    <MessageFormat>Simplify conditional expression.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[bool x = y ? true : false; // [|Id|]]]></Before>
        <After><![CDATA[bool x = y;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool x = y ? z : false; // [|Id|]]]></Before>
        <After><![CDATA[bool x = y && z;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[bool x = y ? true : z; // [|Id|]]]></Before>
        <After><![CDATA[bool x = y || z;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnnecessaryInterpolation">
    <Id>RCS1105</Id>
    <Title>Unncessary interpolation.</Title>
    <MessageFormat>Unncessary interpolation.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = $"a{"b"}c"; // [|Id|]]]></Before>
        <After><![CDATA[string s = $"abc";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveEmptyDestructor">
    <Id>RCS1106</Id>
    <Title>Remove empty destructor.</Title>
    <MessageFormat>Remove empty destructor.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
    ~Foo() // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantStringToCharArrayCall">
    <Id>RCS1107</Id>
    <Title>Remove redundant 'ToCharArray' call.</Title>
    <MessageFormat>Remove redundant 'ToCharArray' call.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[foreach (char ch in s.ToCharArray()) // [|Id|]
{
}]]></Before>
        <After><![CDATA[foreach (char ch in s)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddStaticModifierToAllPartialClassDeclarations">
    <Id>RCS1108</Id>
    <Title>Add 'static' modifier to all partial class declarations.</Title>
    <MessageFormat>Add 'static' modifier to all partial class declarations.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public static partial class Foo
{
}

public partial class Foo // [|Id|]
{
}]]></Before>
        <After><![CDATA[public static partial class Foo
{
}

public static partial class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallCastInsteadOfSelect" IsObsolete="true">
    <Id>RCS1109</Id>
    <Title>Call 'Enumerable.Cast' instead of 'Enumerable.Select'.</Title>
    <MessageFormat>Call 'Enumerable.Cast' instead of 'Enumerable.Select'.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[IEnumerable<object> x = items.Select(f => (object)f); // [|Id|]]]></Before>
        <After><![CDATA[IEnumerable<object> x = items.Cast<object>();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DeclareTypeInsideNamespace">
    <Id>RCS1110</Id>
    <Title>Declare type inside namespace.</Title>
    <MessageFormat>Declare '{0}' inside namespace.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo // [|Id|]
{
}]]></Before>
        <After><![CDATA[namespace Namespace
{
    public class Foo
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddBracesToSwitchSectionWithMultipleStatements">
    <Id>RCS1111</Id>
    <Title>Add braces to switch section with multiple statements.</Title>
    <MessageFormat>Add braces to switch section with multiple statements.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (s)
{
    case "a":
        Foo(); // [|Id|]
        break;
}]]></Before>
        <After><![CDATA[switch (s)
{
    case "a":
        {
            Foo();
            break;
        }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CombineEnumerableWhereMethodChain">
    <Id>RCS1112</Id>
    <Title>Combine 'Enumerable.Where' method chain.</Title>
    <MessageFormat>Combine 'Enumerable.Where' method chain.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[IEnumerable<string> x = items.Where(f => Foo(f)).Where(f => Bar(f)); // [|Id|]]]></Before>
        <After><![CDATA[IEnumerable<string> x = items.Where(f => Foo(f) && Bar(f));]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseStringIsNullOrEmptyMethod">
    <Id>RCS1113</Id>
    <Title>Use 'string.IsNullOrEmpty' method.</Title>
    <MessageFormat>Use 'string.IsNullOrEmpty' method.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (s == null || s.Length == 0) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (string.IsNullOrEmpty(s))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantDelegateCreation">
    <Id>RCS1114</Id>
    <Title>Remove redundant delegate creation.</Title>
    <MessageFormat>Remove redundant delegate creation.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[Changed += new EventHandler(OnChanged); // [|Id|]]]></Before>
        <After><![CDATA[Changed += OnChanged;]]></After>
      </Sample>
      </Samples>
  </Analyzer>
  <Analyzer Identifier="ReplaceReturnStatementWithExpressionStatement" IsObsolete="true">
    <Id>RCS1115</Id>
    <Title>Replace yield/return statement with expression statement.</Title>
    <MessageFormat>Replace {0} statement with expression statement.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AddBreakStatementToSwitchSection" IsObsolete="true">
    <Id>RCS1116</Id>
    <Title>Add break statement to switch section.</Title>
    <MessageFormat>Add break statement to switch section.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AddReturnStatementThatReturnsDefaultValue" IsObsolete="true">
    <Id>RCS1117</Id>
    <Title>Add return statement that returns default value.</Title>
    <MessageFormat>Add return statement that returns default value.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="MarkLocalVariableAsConst">
    <Id>RCS1118</Id>
    <Title>Mark local variable as const.</Title>
    <MessageFormat>Mark local variable as const.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = "a"; // [|Id|]
string s2 = s + "b";]]></Before>
        <After><![CDATA[const string s = "a";
string s2 = s + "b";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallFindInsteadOfFirstOrDefault" IsObsolete="true">
    <Id>RCS1119</Id>
    <Title>Call 'Find' instead of 'FirstOrDefault'.</Title>
    <MessageFormat>Call 'Find' instead of 'FirstOrDefault'.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = list.FirstOrDefault(f => f.StartsWith("a")); // [|Id|]]]></Before>
        <After><![CDATA[string s = list.Find(f => f.StartsWith("a"));]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseElementAccessInsteadOfElementAt" IsObsolete="true">
    <Id>RCS1120</Id>
    <Title>Use [] instead of calling 'ElementAt'.</Title>
    <MessageFormat>Use [] instead of calling 'ElementAt'.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = list.ElementAt(1); // [|Id|]]]></Before>
        <After><![CDATA[var x = list[1];]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseElementAccessInsteadOfFirst" IsObsolete="true">
    <Id>RCS1121</Id>
    <Title>Use [] instead of calling 'First'.</Title>
    <MessageFormat>Use [] instead of calling 'First'.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = list.First(); // [|Id|]]]></Before>
        <After><![CDATA[var x = list[0];]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddMissingSemicolon" IsObsolete="true">
    <Id>RCS1122</Id>
    <Title>Add missing semicolon.</Title>
    <MessageFormat>Add missing semicolon.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AddParenthesesAccordingToOperatorPrecedence">
    <Id>RCS1123</Id>
    <Title>Add parentheses according to operator precedence.</Title>
    <MessageFormat>Add parentheses according to operator precedence.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x || y && z) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x || (y && z))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="InlineLocalVariable">
    <Id>RCS1124</Id>
    <Title>Inline local variable.</Title>
    <MessageFormat>Inline local variable.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[IEnumerable<object> items = GetValues(); // [|Id|]
foreach (object item in items)
{
}]]></Before>
        <After><![CDATA[foreach (object item in GetValues())
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MarkMemberAsStatic" IsObsolete="true">
    <Id>RCS1125</Id>
    <Title>Mark member as static.</Title>
    <MessageFormat>Mark member as static.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AddBracesToIfElse">
    <Id>RCS1126</Id>
    <Title>Add braces to if-else.</Title>
    <MessageFormat>Add braces to {0}.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition)
    Foo(); // [|Id|]
else
    Bar();]]></Before>
        <After><![CDATA[if (condition)
{
    Foo();
}
else
{
    Bar();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MergeLocalDeclarationWithAssignment">
    <Id>RCS1127</Id>
    <Title>Merge local declaration with assignment.</Title>
    <MessageFormat>Merge local declaration with assignment.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s; // [|Id|]
s = "";]]></Before>
        <After><![CDATA[string s = "";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCoalesceExpression">
    <Id>RCS1128</Id>
    <Title>Use coalesce expression.</Title>
    <MessageFormat>Use coalesce expression.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = GetValue(); // [|Id|]

if (s == null)
{
    s = "";
}]]></Before>
        <After><![CDATA[string s = GetValue() ?? "";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantFieldInitialization">
    <Id>RCS1129</Id>
    <Title>Remove redundant field initalization.</Title>
    <MessageFormat>Remove redundant field initialization.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private bool _f = false; // [|Id|]]]></Before>
        <After><![CDATA[private bool _f;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="BitwiseOperationOnEnumWithoutFlagsAttribute">
    <Id>RCS1130</Id>
    <Title>Bitwise operation on enum without Flags attribute.</Title>
    <MessageFormat>Bitwise operation on enum without Flags attribute.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[DayOfWeek x = dayOfWeek | DayOfWeek.Tuesday; // [|Id|]]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ReplaceReturnWithYieldReturn" IsObsolete="true">
    <Id>RCS1131</Id>
    <Title>Replace return with yield return.</Title>
    <MessageFormat>Replace return with yield return.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantOverridingMember">
    <Id>RCS1132</Id>
    <Title>Remove redundant overriding member.</Title>
    <MessageFormat>Remove redundant overriding {0}.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
    public override string ToString() // [|Id|]
    {
        return base.ToString();
    }
}]]></Before>
        <After><![CDATA[public class Foo
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantDisposeOrCloseCall">
    <Id>RCS1133</Id>
    <Title>Remove redundant Dispose/Close call.</Title>
    <MessageFormat>Remove redundant '{0}' call.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[using (streamReader) // [|Id|]
{
    // ...

    streamReader.Dispose();
}]]></Before>
        <After><![CDATA[using (streamReader)
{
    // ...
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantStatement">
    <Id>RCS1134</Id>
    <Title>Remove redundant statement.</Title>
    <MessageFormat>Remove redundant statement.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x)
{
    // ...

    return false; // [|Id|]
}

return false;]]></Before>
        <After><![CDATA[if (x)
{
    // ...
}

return false;]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[public void Foo()
{
    // ...

    return; // [|Id|]
}]]></Before>
        <After><![CDATA[public void Foo()
{
    // ...
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[foreach (object item in items)
{
    /// ...

    continue; // [|Id|]
}]]></Before>
        <After><![CDATA[]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DeclareEnumMemberWithZeroValue">
    <Id>RCS1135</Id>
    <Title>Declare enum member with zero value (when enum has FlagsAttribute).</Title>
    <MessageFormat>Declare enum member with zero value (when enum has FlagsAttribute).</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[[Flags]
public enum Foo // [|Id|]
{
    A = 1,
    B = 2
}]]></Before>
        <After><![CDATA[[Flags]
public enum Foo
{
    None = 0,
    A = 1,
    B = 2
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MergeSwitchSectionsWithEquivalentContent">
    <Id>RCS1136</Id>
    <Title>Merge switch sections with equivalent content.</Title>
    <MessageFormat>Merge switch sections with equivalent content.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[switch (s)
{
    case "a":
        break; // [|Id|]
    case "b":
        break;
}]]></Before>
        <After><![CDATA[switch (s)
{
    case "a":
    case "b":
        break;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddDocumentationComment" IsObsolete="true">
    <Id>RCS1137</Id>
    <Title>Add documentation comment to publicly visible type or member.</Title>
    <MessageFormat>Add documentation comment to publicly visible type or member.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AddSummaryToDocumentationComment">
    <Id>RCS1138</Id>
    <Title>Add summary to documentation comment.</Title>
    <MessageFormat>Add summary to documentation comment.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <summary> // [|Id|]
/// 
/// </summary>
public void Foo()
{
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddSummaryElementToDocumentationComment">
    <Id>RCS1139</Id>
    <Title>Add summary element to documentation comment.</Title>
    <MessageFormat>Add summary element to documentation comment.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <param name="parameter"></param> // [|Id|]
public void Foo(object parameter)
{
}]]></Before>
        <After><![CDATA[/// <summary>
/// 
/// </summary>
/// <param name="parameter"></param>
public void Foo(object parameter)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddExceptionToDocumentationComment">
    <Id>RCS1140</Id>
    <Title>Add exception to documentation comment.</Title>
    <MessageFormat>Add exception to documentation comment.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[/// <summary>
/// ...
/// </summary>
/// <param name="parameter"></param>
public void Foo(object parameter)
{
    if (parameter == null)
        throw new ArgumentNullException(nameof(parameter)); // [|Id|]
}]]></Before>
        <After><![CDATA[/// <summary>
/// ...
/// </summary>
/// <param name="parameter"></param>
/// <exception cref="ArgumentNullException"><paramref name="parameter"/> is <c>null</c>.</exception>
public void Foo(object parameter)
{
    if (parameter == null)
        throw new ArgumentNullException(nameof(parameter));
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddParamElementToDocumentationComment">
    <Id>RCS1141</Id>
    <Title>Add 'param' element to documentation comment.</Title>
    <MessageFormat>Add 'param' element to documentation comment.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <summary>
/// ...
/// </summary>
public void Foo(object parameter) // [|Id|]
{
}]]></Before>
        <After><![CDATA[/// <summary>
/// ...
/// </summary>
/// <param name="parameter"></param>
public void Foo(object parameter)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddTypeParamElementToDocumentationComment">
    <Id>RCS1142</Id>
    <Title>Add 'typeparam' element to documentation comment.</Title>
    <MessageFormat>Add 'typeparam' element to documentation comment.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <summary>
/// ...
/// </summary>
/// <typeparam name="T1"></typeparam>
public class Foo<T1, T2> // [|Id|]
{
}]]></Before>
        <After><![CDATA[/// <summary>
/// ...
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
public class Foo<T1, T2>
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyCoalesceExpression">
    <Id>RCS1143</Id>
    <Title>Simplify coalesce expression.</Title>
    <MessageFormat>Simplify coalesce expression.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = default(string) ?? ""; // [|Id|]]]></Before>
        <After><![CDATA[string s = "";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MarkContainingClassAsAbstract" IsObsolete="true">
    <Id>RCS1144</Id>
    <Title>Mark containing class as abstract.</Title>
    <MessageFormat>Mark containing class as abstract.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantAsOperator">
    <Id>RCS1145</Id>
    <Title>Remove redundant 'as' operator.</Title>
    <MessageFormat>Remove redundant 'as' operator.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = null;

string s2 = s as string; // [|Id|]]]></Before>
        <After><![CDATA[string s2 = s;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseConditionalAccess">
    <Id>RCS1146</Id>
    <Title>Use conditional access.</Title>
    <MessageFormat>Use conditional access.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>6.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[if (s != null && s.StartsWith("a")) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (s?.StartsWith("a") == true)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (dic != null && dic[0].StartsWith("a")) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (dic?[0].StartsWith("a") == true)
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (x != null) // [|Id|]
    x.Foo();]]></Before>
        <After><![CDATA[x?.Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveInapplicableModifier" IsObsolete="true">
    <Id>RCS1147</Id>
    <Title>Remove inapplicable modifier.</Title>
    <MessageFormat>Remove inapplicable modifier.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="RemoveUnreachableCode" IsObsolete="true">
    <Id>RCS1148</Id>
    <Title>Remove unreachable code.</Title>
    <MessageFormat>Remove unreachable code.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="RemoveImplementationFromAbstractMember" IsObsolete="true">
    <Id>RCS1149</Id>
    <Title>Remove implementation from abstract member.</Title>
    <MessageFormat>Remove implementation from {0}.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="CallStringConcatInsteadOfStringJoin" IsObsolete="true">
    <Id>RCS1150</Id>
    <Title>Call string.Concat instead of string.Join.</Title>
    <MessageFormat>Call string.Concat instead of string.Join.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = string.Join("", "a", "b", "c"); // [|Id|]]]></Before>
        <After><![CDATA[string s = string.Concat("a", "b", "c");]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantCast">
    <Id>RCS1151</Id>
    <Title>Remove redundant cast.</Title>
    <MessageFormat>Remove redundant cast.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var b = new Base();

((Foo)b).Bar(); // [|Id|]]]></Before>
        <After><![CDATA[b.Bar();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[IEnumerable<string> x = EnumerateStrings().Cast<string>(); // [|Id|]]]></Before>
        <After><![CDATA[IEnumerable<string> x = EnumerateStrings();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MemberTypeMustMatchOverriddenMemberType" IsObsolete="true">
    <Id>RCS1152</Id>
    <Title>Member type must match overriden member type.</Title>
    <MessageFormat>Member type must match overriden member type.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="AddEmptyLineAfterClosingBrace">
    <Id>RCS1153</Id>
    <Title>Add empty line after closing brace.</Title>
    <MessageFormat>Add empty line after closing brace.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x)
{
} // [|Id|]
Foo();]]></Before>
        <After><![CDATA[if (x)
{
}

Foo();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SortEnumMembers">
    <Id>RCS1154</Id>
    <Title>Sort enum members.</Title>
    <MessageFormat>Sort '{0}' members.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public enum Foo // [|Id|]
{
    D = 4,
    B = 2,
    A = 1,
    C = 3
}]]></Before>
        <After><![CDATA[public enum Foo
{
    A = 1,
    B = 2,
    C = 3,
    D = 4
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseStringComparison">
    <Id>RCS1155</Id>
    <Title>Use StringComparison when comparing strings.</Title>
    <MessageFormat>Use StringComparison when comparing strings.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x.ToLower() == y.ToLower()) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (string.Equals(x, y, StringComparison.OrdinalIgnoreCase))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseStringLengthInsteadOfComparisonWithEmptyString">
    <Id>RCS1156</Id>
    <Title>Use string.Length instead of comparison with empty string.</Title>
    <MessageFormat>Use string.Length instead of comparison with empty string.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (s == "") // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (s?.Length == 0)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CompositeEnumValueContainsUndefinedFlag">
    <Id>RCS1157</Id>
    <Title>Composite enum value contains undefined flag.</Title>
    <MessageFormat>Composite enum value contains undefined flag {0}.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[[Flags]
public enum Foo
{
    None = 0,
    A = 1,
    B = 2,
    C = 4,
    D = 8,
    X = 17 // [|Id|]
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="StaticMemberInGenericTypeShouldUseTypeParameter">
    <Id>RCS1158</Id>
    <Title>Static member in generic type should use a type parameter.</Title>
    <MessageFormat>Static member in generic type should use a type parameter.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[public class Foo<T>
{
    public static void Bar() // [|Id|]
    {
    }
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseGenericEventHandler">
    <Id>RCS1159</Id>
    <Title>Use EventHandler&lt;T&gt;.</Title>
    <MessageFormat>Use EventHandler&lt;T&gt;.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
    public event FooEventHandler EventName; // [|Id|]
}

public delegate void FooEventHandler(object sender, FooEventArgs args);]]></Before>
        <After><![CDATA[public class Foo
{
    public event EventHandler<FooEventArgs> EventName;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AbstractTypeShouldNotHavePublicConstructors">
    <Id>RCS1160</Id>
    <Title>Abstract type should not have public constructors.</Title>
    <MessageFormat>Abstract type should not have public constructors.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public abstract class Foo
{
    public Foo() // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public abstract class Foo
{
    protected Foo()
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="EnumShouldDeclareExplicitValues">
    <Id>RCS1161</Id>
    <Title>Enum should declare explicit values.</Title>
    <MessageFormat>Enum should declare explicit values.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public enum Foo // [|Id|]
{
    A,
    B,
    C,
}]]></Before>
        <After><![CDATA[public enum Foo
{
    A = 0,
    B = 1,
    C = 2,
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidChainOfAssignments">
    <Id>RCS1162</Id>
    <Title>Avoid chain of assignments.</Title>
    <MessageFormat>Avoid chain of assignments.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[x = y = z; // [|Id|]]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnusedParameter">
    <Id>RCS1163</Id>
    <Title>Unused parameter.</Title>
    <MessageFormat>Unused parameter '{0}'.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public bool Bar(object parameter) // [|Id|]
{
    return false;
}]]></Before>
      </Sample>
    </Samples>
    <Remarks>This analyzer does not provide a code fix. Use built-in "Change signature.." dialog to remove a parameter.

Unused parameter is not reported when its name consists of underscore(s).</Remarks>
  </Analyzer>
  <Analyzer Identifier="UnusedTypeParameter">
    <Id>RCS1164</Id>
    <Title>Unused type parameter.</Title>
    <MessageFormat>Unused type parameter '{0}'.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public bool Bar<T>() // [|Id|]
{
    return false
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnconstrainedTypeParameterCheckedForNull">
    <Id>RCS1165</Id>
    <Title>Unconstrained type parameter checked for null.</Title>
    <MessageFormat>Unconstrained type parameter checked for null.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public void Foo<T1>() where T1 : new()
{
    var x = default(T1);

    if (x == null) // [|Id|]
    {
    }
}]]></Before>
        <After>
          <![CDATA[if (EqualityComparer<T1>.Default.Equals(x, default(T1)))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ValueTypeObjectIsNeverEqualToNull">
    <Id>RCS1166</Id>
    <Title>Value type object is never equal to null.</Title>
    <MessageFormat>Value type object is never equal to null.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[int x = 0;

// ...

if (x == null) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x == 0)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OverridingMemberCannotChangeAccessModifiers" IsObsolete="true">
    <Id>RCS1167</Id>
    <Title>Overriding member cannot change access modifiers.</Title>
    <MessageFormat>Overriding member cannot change access modifiers.</MessageFormat>
    <Category>ErrorFix</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="ParameterNameDiffersFromBase">
    <Id>RCS1168</Id>
    <Title>Parameter name differs from base name.</Title>
    <MessageFormat>Parameter name '{0}' differs from base name '{1}'.</MessageFormat>
    <Category>Maintainability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[interface IFoo
{
    string Bar(object parameter);
}

abstract class Foo : IFoo
{
    public abstract string Bar(object value); // [|Id|]
}]]></Before>
        <After><![CDATA[interface IFoo
{
    string Bar(object parameter);
}

abstract class Foo : IFoo
{
    public abstract string Bar(object parameter)
};]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MakeFieldReadOnly">
    <Id>RCS1169</Id>
    <Title>Make field read-only.</Title>
    <MessageFormat>Make field read-only.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo
{
    private int _f; // [|Id|]

    public Foo()
    {
        _f = 0;
    }
}]]></Before>
        <After><![CDATA[private readonly int _f;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseReadOnlyAutoProperty">
    <Id>RCS1170</Id>
    <Title>Use read-only auto-implemented property.</Title>
    <MessageFormat>Use read-only auto-implemented property.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>6.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[public object Foo { get; private set; } // [|Id|]]]></Before>
        <After><![CDATA[public object Foo { get; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyLazyInitialization">
    <Id>RCS1171</Id>
    <Title>Simplify lazy initialization.</Title>
    <MessageFormat>Simplify lazy initialization.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[public object Foo()
{
    if (_foo == null) // [|Id|]
    {
        _foo = Initialize();
    }

    return _foo;
}]]></Before>
        <After>
          <![CDATA[public object Foo()
{
    return _foo ?? (_foo = Initialize());
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseIsOperatorInsteadOfAsOperator">
    <Id>RCS1172</Id>
    <Title>Use 'is' operator instead of 'as' operator.</Title>
    <MessageFormat>Use 'is' operator instead of 'as' operator.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x as string != null) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x is string)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseCoalesceExpressionInsteadOfIf">
    <Id>RCS1173</Id>
    <Title>Use coalesce expression instead of if.</Title>
    <MessageFormat>Use coalesce expression instead of if.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x != null) // [|Id|]
{
    z = x;
}
else
{
    z = y;
}]]></Before>
        <After><![CDATA[z = x ?? y;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantAsyncAwait">
    <Id>RCS1174</Id>
    <Title>Remove redundant async/await.</Title>
    <MessageFormat>Remove redundant async/await.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public static async Task<object> FooAsync() // [|Id|]
{
    return await GetAsync().ConfigureAwait(false);
}]]></Before>
        <After><![CDATA[public static Task<object> FooAsync()
{
    return GetAsync();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnusedThisParameter">
    <Id>RCS1175</Id>
    <Title>Unused this parameter.</Title>
    <MessageFormat>Unused this parameter '{0}'.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public static bool Bar(this Foo foo, object parameter) // [|Id|]
{
    return parameter != null;
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseVarInsteadOfExplicitTypeWhenTypeIsNotObvious">
    <Id>RCS1176</Id>
    <Title>Use 'var' instead of explicit type (when the type is not obvious).</Title>
    <MessageFormat>Use 'var' instead of explicit type.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = GetValue(); // [|Id|]]]></Before>
        <After><![CDATA[var s = GetValue();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseVarInsteadOfExplicitTypeInForEach">
    <Id>RCS1177</Id>
    <Title>Use 'var' instead of explicit type (in foreach).</Title>
    <MessageFormat>Use 'var' instead of explicit type.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[foreach (string item in items) // [|Id|]
{
}]]></Before>
        <After>
          <![CDATA[foreach (var item in items)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallDebugFailInsteadOfDebugAssert" IsObsolete="true">
    <Id>RCS1178</Id>
    <Title>Call Debug.Fail instead of Debug.Assert.</Title>
    <MessageFormat>Call Debug.Fail instead of Debug.Assert.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[Debug.Assert(false, "message"); // [|Id|]]]></Before>
        <After><![CDATA[Debug.Fail("message");]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseReturnInsteadOfAssignment">
    <Id>RCS1179</Id>
    <Title>Use return instead of assignment.</Title>
    <MessageFormat>Use return instead of assignment.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[if (condition) // [|Id|]
{
    x = 1;
}
else
{
    x = 2;
}

return x;]]></Before>
        <After><![CDATA[if (condition)
{
    return 1;
}
else
{
    return 2;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="InlineLazyInitialization">
    <Id>RCS1180</Id>
    <Title>Inline lazy initialization.</Title>
    <MessageFormat>Inline lazy initialization.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[List<object> items = null;

// ...

if (items == null) // [|Id|]
{
    items = new List<object>();
}

items.Add(x);]]></Before>
        <After><![CDATA[(items ?? (items = new List<object>())).Add(x);]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ConvertCommentToDocumentationComment">
    <Id>RCS1181</Id>
    <Title>Convert comment to documentation comment.</Title>
    <MessageFormat>Convert comment to documentation comment.</MessageFormat>
    <Category>General</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[// Represents foo. // [|Id|]
public class Foo
{
}]]></Before>
        <After><![CDATA[/// <summary>
/// Represents foo.
/// </summary>
public class Foo
{
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[public string Value { get; } // Gets a value. // [|Id|]]]></Before>
        <After><![CDATA[/// <summary>
/// Gets a value.
/// </summary>
public string Value { get; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantBaseInterface">
    <Id>RCS1182</Id>
    <Title>Remove redundant base interface.</Title>
    <MessageFormat>Interface '{0}' is already implemented by '{1}'.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo<T> : List<T>, IEnumerable<T> // [|Id|]
{
}]]></Before>
        <After><![CDATA[public class Foo<T> : List<T>
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatInitializerWithSingleExpressionOnSingleLine">
    <Id>RCS1183</Id>
    <Title>Format initializer with single expression on single line.</Title>
    <MessageFormat>Format initializer with single expression on single line.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var dic = new Dictionary<int, string>()
{ // [|Id|]
    { 0, "0" }
};]]></Before>
        <After><![CDATA[var dic = new Dictionary<int, string>() { { 0, "0" } };]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatConditionalExpression">
    <Id>RCS1184</Id>
    <Title>Format conditional expression (format ? and : on next line).</Title>
    <MessageFormat>Format conditional expression.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var y = (x) ? // [|Id|]
Foo() :
Bar();]]></Before>
        <After><![CDATA[var y = (x)
? Foo()
: Bar();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="FormatSingleLineBlock">
    <Id>RCS1185</Id>
    <Title>Format single-line block.</Title>
    <MessageFormat>Format single-line block.</MessageFormat>
    <Category>Formatting</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[void Foo() { Bar(); } // [|Id|]]]></Before>
        <After><![CDATA[void Foo()
{
    Bar();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseRegexInstanceInsteadOfStaticMethod">
    <Id>RCS1186</Id>
    <Title>Use Regex instance instead of static method.</Title>
    <MessageFormat>Use Regex instance instead of static method.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private void Bar()
{
    bool isMatch = Regex.IsMatch("abc", @"\w"); // [|Id|]
}]]></Before>
        <After><![CDATA[private readonly Regex _regex = new Regex(@"\w");

private void Bar()
{
    bool isMatch = _regex.IsMatch("abc");
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseConstantInsteadOfField">
    <Id>RCS1187</Id>
    <Title>Use constant instead of field.</Title>
    <MessageFormat>Use constant instead of field.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[private static readonly int _foo = 0; // [|Id|]]]></Before>
        <After><![CDATA[private const int _foo = 0;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantAutoPropertyInitialization">
    <Id>RCS1188</Id>
    <Title>Remove redundant auto-property initialization.</Title>
    <MessageFormat>Remove redundant auto-property initialization.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public string Foo { get; set; } = null; // [|Id|]]]></Before>
        <After><![CDATA[public string Foo { get; set; }]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddOrRemoveRegionName">
    <Id>RCS1189</Id>
    <Title>Add or remove region name.</Title>
    <MessageFormat>{0} region name {1} #endregion.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[#region Methods
public static void Foo()
{
}
#endregion // [|Id|]]]></Before>
        <After><![CDATA[#region Methods
public static void Foo()
{
}
#endregion Methods]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="JoinStringExpressions">
    <Id>RCS1190</Id>
    <Title>Join string expressions.</Title>
    <MessageFormat>Join string expressions.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = "a" + "b"; // [|Id|]]]></Before>
        <After><![CDATA[string s = "ab";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DeclareEnumValueAsCombinationOfNames">
    <Id>RCS1191</Id>
    <Title>Declare enum value as combination of names.</Title>
    <MessageFormat>Declare enum value as combination of names.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[[Flags]
public enum Foo
{
    None = 0,
    A = 1,
    B = 2,
    C = 4,
    ABC = 7 // [|Id|]
}]]></Before>
        <After><![CDATA[[Flags]
public enum Foo
{
    None = 0,
    A = 1,
    B = 2,
    C = 4,
    ABC = A | B | C
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseRegularStringLiteralInsteadOfVerbatimStringLiteral">
    <Id>RCS1192</Id>
    <Title>Use regular string literal instead of verbatim string literal.</Title>
    <MessageFormat>Use regular string literal instead of verbatim string literal.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = @"x"; // [|Id|]]]></Before>
        <After><![CDATA[string s = "x";]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OverridingMemberCannotChangeParamsModifier">
    <Id>RCS1193</Id>
    <Title>Overriding member cannot change 'params' modifier.</Title>
    <MessageFormat>Overriding member cannot change 'params' modifier.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Base
{
    public virtual void Foo(params object[] values)
    {
    }
}

public class Derived : Base
{
    public override void Foo(object[] values) // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public class Derived : Base
{
    public override void Foo(params object[] values)
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ImplementExceptionConstructors">
    <Id>RCS1194</Id>
    <Title>Implement exception constructors.</Title>
    <MessageFormat>Implement exception constructors.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class FooException : Exception // [|Id|]
{
}]]></Before>
        <After><![CDATA[public class FooException : Exception
{
    public FooException() : base()
    {
    }

    public FooException(string message) : base(message)
    {
    }

    public FooException(string message, Exception innerException) : base(message, innerException)
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseExclusiveOrOperator">
    <Id>RCS1195</Id>
    <Title>Use ^ operator.</Title>
    <MessageFormat>Use ^ operator.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if ((x && !y) || (!x && y)) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x ^ y)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallExtensionMethodAsInstanceMethod">
    <Id>RCS1196</Id>
    <Title>Call extension method as instance method.</Title>
    <MessageFormat>Call extension method as instance method.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = Enumerable.Select(items, f => f.ToString()) // [|Id|]]]></Before>
        <After><![CDATA[var x = items.Select(f => f.ToString());]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OptimizeStringBuilderAppendCall">
    <Id>RCS1197</Id>
    <Title>Optimize StringBuilder.Append/AppendLine call.</Title>
    <MessageFormat>Optimize StringBuilder.{0} call.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[sb.Append(s + "x"); // [|Id|]]]></Before>
        <After><![CDATA[sb.Append(s).Append("x");]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidBoxingOfValueType">
    <Id>RCS1198</Id>
    <Title>Avoid unnecessary boxing of value type.</Title>
    <MessageFormat>Avoid unnecessary boxing of value type.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = null;
int i = 0;

// ...

string x = s + i; // [|Id|]]]></Before>
        <After><![CDATA[string x = s + i.ToString();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyBooleanExpression">
    <Id>RCS1199</Id>
    <Title>Simplify boolean expression.</Title>
    <MessageFormat>Simplify boolean expression.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[bool? x = null;

// ...

if (x.HasValue && x.Value) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x == true)
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallThenByInsteadOfOrderBy">
    <Id>RCS1200</Id>
    <Title>Call 'Enumerable.ThenBy' instead of 'Enumerable.OrderBy'.</Title>
    <MessageFormat>Call 'Enumerable.ThenBy{0}' instead of 'Enumerable.OrderBy{0}'.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = items.OrderBy(f => f.Surname).OrderBy(f => f.Name); // [|Id|]]]></Before>
        <After><![CDATA[var x = items.OrderBy(f => f.Surname).ThenBy(f => f.Name);]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseMethodChaining">
    <Id>RCS1201</Id>
    <Title>Use method chaining.</Title>
    <MessageFormat>Use method chaining.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[sb = new StringBuilder();

sb.Append("a"); // [|Id|]
sb.Append("b");
sb.Append("c");]]></Before>
        <After><![CDATA[sb = new StringBuilder();

sb.Append("a")
    .Append("b")
    .Append("c");]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidNullReferenceException">
    <Id>RCS1202</Id>
    <Title>Avoid NullReferenceException.</Title>
    <MessageFormat>Avoid NullReferenceException.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string s = items.FirstOrDefault().ToString(); // [|Id|]]]></Before>
        <After><![CDATA[string s = items.FirstOrDefault()?.ToString();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseAttributeUsageAttribute">
    <Id>RCS1203</Id>
    <Title>Use AttributeUsageAttribute.</Title>
    <MessageFormat>Use AttributeUsageAttribute.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class FooAttribute : Attribute // [|Id|]
{
}]]></Before>
        <After><![CDATA[[AttributeUsageAttribute(AttributeTargets.All, AllowMultiple = false)]
public class FooAttribute : Attribute
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseEventArgsEmpty">
    <Id>RCS1204</Id>
    <Title>Use EventArgs.Empty.</Title>
    <MessageFormat>Use EventArgs.Empty.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = new EventArgs(); // [|Id|]]]></Before>
        <After><![CDATA[var x = EventArgs.Empty;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OrderNamedArguments">
    <Id>RCS1205</Id>
    <Title>Order named arguments according to the order of parameters.</Title>
    <MessageFormat>Order named arguments according to the order of parameters.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[using (var sm = new StreamReader(
    stream: default(Stream),
    encoding: Encoding.UTF8,
    bufferSize: 0, // [|Id|]
    leaveOpen: false,
    detectEncodingFromByteOrderMarks: true))
{
}]]></Before>
        <After><![CDATA[using (var sm = new StreamReader(
    stream: default(Stream),
    encoding: Encoding.UTF8,
    detectEncodingFromByteOrderMarks: true,
    bufferSize: 0,
    leaveOpen: false))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseConditionalAccessInsteadOfConditionalExpression">
    <Id>RCS1206</Id>
    <Title>Use conditional access instead of conditional expression.</Title>
    <MessageFormat>Use conditional access instead of conditional expression.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>6.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = new Foo();

// ...

        string s = (x != null) ? x.ToString() : null; // [|Id|]]]></Before>
        <After><![CDATA[string s = x?.ToString();]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[int? x = null;

// ...

int i = (x != null) ? x.Value.GetHashCode() : 0; // [|Id|]]]></Before>
        <After><![CDATA[int i = x?.GetHashCode() ?? 0;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseMethodGroupInsteadOfAnonymousFunction">
    <Id>RCS1207</Id>
    <Title>Use method group instead of anonymous function.</Title>
    <MessageFormat>Use method group instead of anonymous function.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = items.Select(f => Foo(f)); // [|Id|]]]></Before>
        <After><![CDATA[var x = items.Select(Foo);]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ReduceIfNesting">
    <Id>RCS1208</Id>
    <Title>Reduce if nesting.</Title>
    <MessageFormat>Reduce if nesting.</MessageFormat>
    <Category>Style</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition1) // [|Id|]
{
    Foo1();

    if (condition2)
    {
        Foo2();

        if (condition3)
        {
            Foo3();
        }
    }
}]]></Before>
        <After><![CDATA[if (!condition1)
{
    return;
}

Foo1();

if (!condition2)
{
    return;
}

Foo2();

if (!condition3)
{
    return;
}

Foo3();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OrderTypeParameterConstraints">
    <Id>RCS1209</Id>
    <Title>Order type parameter constraints.</Title>
    <MessageFormat>Order type parameter constraints.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo<T1, T2, T3>
    where T3 : class // [|Id|]
    where T2 : class
    where T1 : class
{
}]]></Before>
        <After><![CDATA[public class Foo<T1, T2, T3>
    where T1 : class
    where T2 : class
    where T3 : class
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ReturnTaskInsteadOfNull">
    <Id>RCS1210</Id>
    <Title>Return Task.FromResult instead of returning null.</Title>
    <MessageFormat>Return Task.FromResult instead of returning null.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[Task<object> GetAsync()
{
    return null; // [|Id|]
}]]></Before>
        <After><![CDATA[Task<object> GetAsync()
{
    return Task.FromResult<object>(null);
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[Task<object> GetAsync()
{
    return _foo?.GetAsync(); // [|Id|]
}]]></Before>
        <After><![CDATA[Task<object> GetAsync()
{
    Foo x = _foo;
    if (x != null)
    {
        return _foo.GetAsync();
    }
    else
    {
        return Task.FromResult<object>(null);
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveUnnecessaryElseClause">
    <Id>RCS1211</Id>
    <Title>Remove unnecessary else clause.</Title>
    <MessageFormat>Remove unnecessary else clause.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (condition)
{
    return WhenTrue();
}
else // [|Id|]
{
    return WhenFalse();
}]]></Before>
        <After><![CDATA[if (condition)
{
    return WhenTrue();
}

return WhenFalse();]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveRedundantAssignment">
    <Id>RCS1212</Id>
    <Title>Remove redundant assignment.</Title>
    <MessageFormat>Remove redundant assignment.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[bool Foo()
{
    // ...

    f = false; // [|Id|]
    return f;
}]]></Before>
        <After><![CDATA[bool Foo()
{
    // ...

    return false;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="RemoveUnusedMemberDeclaration">
    <Id>RCS1213</Id>
    <Title>Remove unused member declaration.</Title>
    <MessageFormat>Remove unused {0} declaration.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
  </Analyzer>
  <Analyzer Identifier="UnnecessaryInterpolatedString">
    <Id>RCS1214</Id>
    <Title>Unnecessary interpolated string.</Title>
    <MessageFormat>Unnecessary interpolated string.</MessageFormat>
    <Category>Simplification</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[string x = null;
// ...

string y = $"{x}";]]></Before>
        <After><![CDATA[string y = x;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ExpressionIsAlwaysEqualToTrueOrFalse">
    <Id>RCS1215</Id>
    <Title>Expression is always equal to true/false.</Title>
    <MessageFormat>Expression is always equal to '{0}'.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Warning</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[uint i = 0;

// ...

if (i >= 0) // [|Id|]
{
}]]></Before>
      </Sample>
      <Sample>
        <Before>
          <![CDATA[var items = new List<object>();

// ...


if (items.Count < 0) // [|Id|]
{
}]]></Before>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnnecessaryUnsafeContext">
    <Id>RCS1216</Id>
    <Title>Unnecessary unsafe context.</Title>
    <MessageFormat>Unnecessary unsafe context.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public unsafe class Foo // [|Id|]
{
    public Foo()
    {
        unsafe // [|Id|]
        {
            Bar();
        }
    }

    private unsafe void Bar() // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public class Foo
{
    public Foo()
    {
        Bar();
    }

    private void Bar()
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ConvertInterpolatedStringToConcatenation">
    <Id>RCS1217</Id>
    <Title>Convert interpolated string to concatenation.</Title>
    <MessageFormat>Convert interpolated string to concatenation.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[string x = null;
// ...

string y = $"{x}{x}{x}"; // [|Id|]]]></Before>
        <After><![CDATA[string y = x + x + x;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="SimplifyCodeBranching">
    <Id>RCS1218</Id>
    <Title>Simplify code branching.</Title>
    <MessageFormat>Simplify code branching.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x) // [|Id|]
{
}
else
{
  M();
}]]></Before><After><![CDATA[if (!x)
{
  M();
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[while (true)
{
  if (x)  // [|Id|]
  {
    M();
  }
  else
  {
    break;
  }
}]]></Before>
        <After><![CDATA[while (x)
{
  M();
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[while (true)
{
  if (x)  // [|Id|]
  {
    break;
  }

  M();
}]]></Before>
        <After><![CDATA[while (!x)
{
  M();
      
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[do
{
  M();

  if (x)  // [|Id|]
  {
    break;
  }
  
} while (true);]]></Before>
        <After><![CDATA[do
{
  M();

} while (!x);]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (x)
{
  do
  {
    M();
  }
  while (x);]]></Before>
        <After><![CDATA[while (x)
{
  M();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="CallSkipAndAnyInsteadOfCount">
    <Id>RCS1219</Id>
    <Title>Call 'Enumerable.Skip' and 'Enumerable.Any' instead of 'Enumerable.Count'.</Title>
    <MessageFormat>Call 'Enumerable.Skip' and 'Enumerable.Any' instead of 'Enumerable.Count'.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[if (enumerable.Count() > x) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (enumerable.Skip(x).Any())
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UsePatternMatchingInsteadOfIsAndCast">
    <Id>RCS1220</Id>
    <Title>Use pattern matching instead of combination of 'is' operator and cast operator.</Title>
    <MessageFormat>Use pattern matching instead of combination of 'is' operator and cast operator.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>7.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[if (x is T && Foo((T)x)) // [|Id|]
{
}]]></Before>
        <After><![CDATA[if (x is T y && Foo(y))
{
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UsePatternMatchingInsteadOfAsAndNullCheck">
    <Id>RCS1221</Id>
    <Title>Use pattern matching instead of combination of 'as' operator and null check.</Title>
    <MessageFormat>Use pattern matching instead of combination of 'as' operator and null check.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>7.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[var y = x as Foo; // [|Id|]

if (y == null)
{
    return;
}]]></Before>
        <After><![CDATA[if (!(x is Foo y))
{
    return;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MergePreprocessorDirectives">
    <Id>RCS1222</Id>
    <Title>Merge preprocessor directives.</Title>
    <MessageFormat>Merge preprocessor directives.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[#pragma warning disable CS0000
#pragma warning disable CS0001
]]></Before>
        <After><![CDATA[#pragma warning disable CS0000, CS0001]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MarkTypeWithDebuggerDisplayAttribute">
    <Id>RCS1223</Id>
    <Title>Mark publicly visible type with DebuggerDisplay attribute.</Title>
    <MessageFormat>Mark '{0}' with DebuggerDisplay attribute.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo // [|Id|]
{
}]]></Before>
        <After><![CDATA[[DebuggerDisplay("{DebuggerDisplay,nq}")]
public class Foo
{
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string DebuggerDisplay
    {
        get { return ToString(); }
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MakeMethodExtensionMethod">
    <Id>RCS1224</Id>
    <Title>Make method an extension method.</Title>
    <MessageFormat>Make method an extension method.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary>Public/internal method in public/internal static class whose name ends with "Extensions" should be an extension method.</Summary>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[public static class FooExtensions
{
    public static string Bar(Foo foo) // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[public static class FooExtensions
{
    public static string Bar(this Foo foo)
    {
    }
}]]>
        </After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MakeClassSealed">
    <Id>RCS1225</Id>
    <Title>Make class sealed.</Title>
    <MessageFormat>Make class sealed.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary>A class that has only private constructors should be marked as sealed.</Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[public class Foo // [|Id|]
{
    private Foo()
    {
    }
}]]></Before>
<After><![CDATA[public sealed class Foo
{
    private Foo()
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AddParagraphToDocumentationComment">
    <Id>RCS1226</Id>
    <Title>Add paragraph to documentation comment.</Title>
    <MessageFormat>Add paragraph to documentation comment.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before>
          <![CDATA[/// <summary>
/// summary1 // [|Id|]
/// 
/// summary2 // [|Id|]
/// summary3
/// </summary>
class Foo
{
}]]>
        </Before>
        <After>
          <![CDATA[/// <summary>
/// <para>summary1</para>
/// <para>
/// summary2
/// summary3
/// </para>
/// </summary>
class Foo
{
}]]>
        </After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ValidateArgumentsCorrectly">
    <Id>RCS1227</Id>
    <Title>Validate arguments correctly.</Title>
    <MessageFormat>Validate arguments correctly.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary>
      An iterator method (a method that contains `yield`) will not validate arguments until the caller begins to enumerate the result items.

      To ensure that arguments are validated immediately (when the method is called), move
      the iterator to a separate method (local function).
    </Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[IEnumerable<object> Foo(IEnumerable<object> items)
{
    if (items == null)
        throw new ArgumentNullException(nameof(items));

    foreach (object item in items) // [|Id|]
        yield return item;
}]]></Before>
        <After><![CDATA[IEnumerable<object> Foo(IEnumerable<object> items)
{
    if (items == null)
        throw new ArgumentNullException(nameof(items));

    return FooIterator();

    IEnumerable<object> FooIterator()
    {
        foreach (object item in items)
            yield return item;    
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnusedElementInDocumentationComment">
    <Id>RCS1228</Id>
    <Title>Unused element in documentation comment.</Title>
    <MessageFormat>Unused element in documentation comment.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>true</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>true</SupportsFadeOutAnalyzer>
    <Summary></Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[/// <summary>
/// 
/// </summary>
/// <returns></returns> // [|Id|]
public string Foo()
{
    return null;
}
]]></Before>
        <After><![CDATA[/// <summary>
/// 
/// </summary>
public string Foo()
{
    return null;
}
]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseAsyncAwait">
    <Id>RCS1229</Id>
    <Title>Use async/await when necessary.</Title>
    <MessageFormat>Use async/await when necessary.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary></Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[Task<object> FooAsync()
{
    using (var service = CreateService()) // [|Id|]
    {
        return service.GetAsync();
    }
}
]]></Before>
        <After><![CDATA[async Task<object> FooAsync()
{
    using (var service = CreateService())
    {
        return await service.GetAsync();
    }
}]]></After>
      </Sample>
    </Samples>
    <Remarks></Remarks>
    <Links>
      <Link>
        <Url>http://thebillwagner.com/Blog/Item/2017-05-03-ThecuriouscaseofasyncawaitandIDisposable</Url>
        <Text>The curious case of async, await, and IDisposable</Text>
      </Link>
    </Links>
  </Analyzer>
  <Analyzer Identifier="UnnecessaryUsageOfEnumerator">
    <Id>RCS1230</Id>
    <Title>Unnecessary usage of enumerator.</Title>
    <MessageFormat>Unnecessary usage of enumerator.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[using (var en = items.GetEnumerator()) // [|Id|]
{
    while (en.MoveNext())
    {
        yield return en.Current;
    }
}]]></Before>
        <After><![CDATA[foreach (var item in items)
{
    yield return item;
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="MakeParameterRefReadOnly">
    <Id>RCS1231</Id>
    <Title>Make parameter ref read-only.</Title>
    <MessageFormat>Make parameter ref read-only.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>false</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>7.2</MinLanguageVersion>
    <Summary></Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[readonly struct C
{
    void M(C c) // [|Id|]
    {
    }
}]]></Before>
        <After><![CDATA[readonly struct C
{
    void M(in C c)
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OrderElementsInDocumentationComment">
    <Id>RCS1232</Id>
    <Title>Order elements in documentation comment.</Title>
    <MessageFormat>Order elements in documentation comment.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary></Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[class C
{
    /// <summary></summary>
    /// <param name="p3"></param> [|Id|]
    /// <param name="p2"></param>
    /// <param name="p1"></param>
    void M(object p1, object p2, object p3)
    {
    }
}]]></Before>
        <After><![CDATA[class C
{
    /// <summary></summary>
    /// <param name="p1"></param>
    /// <param name="p2"></param>
    /// <param name="p3"></param>
    void M(object p1, object p2, object p3)
    {
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseShortCircuitingOperator">
    <Id>RCS1233</Id>
    <Title>Use short-circuiting operator.</Title>
    <MessageFormat>Use short-circuiting operator.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary></Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[boolExpr1 & boolExpr2 [|Id|]]]></Before>
        <After><![CDATA[boolExpr1 && boolExpr2]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[boolExpr1 | boolExpr2 [|Id|]]]></Before>
        <After><![CDATA[boolExpr1 || boolExpr2]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="DuplicateEnumValue">
    <Id>RCS1234</Id>
    <Title>Duplicate enum value.</Title>
    <MessageFormat>Duplicate enum value.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary></Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[enum E
{
    A = 1,
    B = 2,
    C = 2, [|Id|]
}]]></Before>
        <After><![CDATA[enum E
{
    A = 1,
    B = 2,
    C = B,
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="OptimizeMethodCall">
    <Id>RCS1235</Id>
    <Title>Optimize method call.</Title>
    <MessageFormat>Optimize '{0}' call.</MessageFormat>
    <Category>Performance</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[string.Compare(x, y, StringComparison.Ordinal) // [|Id|]]]></Before>
        <After><![CDATA[string.CompareOrdinal(x, y)]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[string.Compare(x, y, StringComparison.CurrentCulture) == 0 // [|Id|]]]></Before>
        <After><![CDATA[string.Equals(x, y, StringComparison.CurrentCulture)]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[string.Join("", x, z, y) // [|Id|]]]></Before>
        <After><![CDATA[string.Concat(x, y, z)]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[Debug.Assert(false, "message"); // [|Id|]]]></Before>
        <After><![CDATA[Debug.Fail("message");]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[if (dic.ContainsKey(key)) // [|Id|]
{
  dic[key] = value;
}
else
{
  dic.Add(key, value);
}]]></Before>
        <After><![CDATA[dic[key] = value;]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseExceptionFilter">
    <Id>RCS1236</Id>
    <Title>Use exception filter.</Title>
    <MessageFormat>Use exception filter.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <MinLanguageVersion>6.0</MinLanguageVersion>
    <Samples>
      <Sample>
        <Before><![CDATA[try
{
}
catch (Exception ex)
{
    if (!(ex is InvalidOperationException)) // [|Id|]
    {
        throw;
    }

    return;
}]]></Before>
        <After><![CDATA[try
{
}
catch (Exception ex) when (ex is InvalidOperationException)
{
    return;
}]]></After>
      </Sample>
    </Samples>
    <Links>
      <Link>
        <Url>https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-6#exception-filters</Url>
        <Text>What's New in C# 6.0 - Exception Filters</Text>
      </Link>
    </Links>
  </Analyzer>
  <Analyzer Identifier="UseBitShiftOperator">
    <Id>RCS1237</Id>
    <Title>Use bit shift operator.</Title>
    <MessageFormat>Use bit shift operator.</MessageFormat>
    <Category>Usage</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[[Flags]
enum Foo // [|Id|]
{
    None = 0,
    Alpha = 1,
    Beta = 2,
    Gamma = 4,
}]]></Before>
        <After><![CDATA[[Flags]
enum Foo
{
    None = 0,
    Alpha = 1,
    Beta = 1 << 1,
    Gamma = 1 << 2,
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="AvoidNestedConditionalOperators">
    <Id>RCS1238</Id>
    <Title>Avoid nested ?: operators.</Title>
    <MessageFormat>Avoid nested ?: operators.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[var x = (a) ? "a" : (b) ? "b" : "c";]]></Before>
        <After><![CDATA[var x;
if (a)
{
    x = "a";
}
else if (b)
{
    x = "b";
}
else
{
    x = "c";
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UseForStatementInsteadOfWhileStatement">
    <Id>RCS1239</Id>
    <Title>Use 'for' statement instead of 'while' statement.</Title>
    <MessageFormat>Use 'for' statement instead of 'while' statement.</MessageFormat>
    <Category>Readability</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[int i = 0;
while (x)
{
    M();
    i++;
}]]></Before>
        <After><![CDATA[for (int i = 0; f; i++)
{
    M();
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="UnnecessaryOperator">
    <Id>RCS1240</Id>
    <Title>Operator is unnecessary.</Title>
    <MessageFormat>The '{0}' operator is unnecessary.</MessageFormat>
    <Category>Redundancy</Category>
    <DefaultSeverity>Info</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Samples>
      <Sample>
        <Before><![CDATA[array.Length <= 0 [|Id|]]]></Before>
        <After><![CDATA[array.Length == 0]]></After>
      </Sample>
    </Samples>
  </Analyzer>
  <Analyzer Identifier="ImplementNonGenericCounterpart">
    <Id>RCS1241</Id>
    <Title>Implement non-generic counterpart.</Title>
    <MessageFormat>Implement {0} when implementing {0}&lt;T&gt;.</MessageFormat>
    <Category>Design</Category>
    <DefaultSeverity>Hidden</DefaultSeverity>
    <IsEnabledByDefault>true</IsEnabledByDefault>
    <SupportsFadeOut>false</SupportsFadeOut>
    <SupportsFadeOutAnalyzer>false</SupportsFadeOutAnalyzer>
    <Summary>Publicly visible type that implements `IComparable&lt;T&gt;`, `IComparer&lt;T&gt;` or `IEqualityComparer&lt;T&gt;` should implement their non-generic counterpart.</Summary>
    <Samples>
      <Sample>
        <Before><![CDATA[using System;
using System.Collections.Generic;

public class C
{
}

public abstract class Comparable : IComparable<C> [|Id|]
{
    public abstract int CompareTo(C other);
}]]></Before>
        <After><![CDATA[using System;
using System.Collections.Generic;

public class C
{
}

public abstract class Comparable : IComparable<C>, IComparable
{
    public abstract int CompareTo(C other);

    public int CompareTo(object obj)
    {
        if (obj == null)
        {
            return 1;
        }

        if (obj is C x)
        {
            return CompareTo(x);
        }

        throw new ArgumentException("""", nameof(obj));
    }
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[using System;
using System.Collections;
using System.Collections.Generic;

public class C
{
}

public abstract class Comparer : IComparer<C> [|Id|]
{
    public abstract int Compare(C x, C y);
}]]></Before>
        <After><![CDATA[using System;
using System.Collections;
using System.Collections.Generic;

public class C
{
}

public abstract class Comparer : IComparer<C>, IComparer
{
    public abstract int Compare(C x, C y);

    public int Compare(object x, object y)
    {
        if (x == y)
        {
            return 0;
        }

        if (x == null)
        {
            return -1;
        }

        if (y == null)
        {
            return 1;
        }

        if (x is global::C a
            && y is global::C b)
        {
            return Compare(a, b);
        }

        if (x is IComparable ic)
        {
            return ic.CompareTo(y);
        }

        throw new ArgumentException("""", nameof(x));
    }
}]]></After>
      </Sample>
      <Sample>
        <Before><![CDATA[using System;
using System.Collections;
using System.Collections.Generic;

public class C
{
}

public abstract class EqualityComparer : IEqualityComparer<C> [|Id|]
{
    public abstract bool Equals(C x, C y);

    public abstract int GetHashCode(C obj);
}]]></Before>
        <After><![CDATA[using System;
using System.Collections;
using System.Collections.Generic;

public class C
{
}

public abstract class EqualityComparer : IEqualityComparer<C>, IEqualityComparer
{
    public abstract bool Equals(C x, C y);

    public abstract int GetHashCode(C obj);

    new public bool Equals(object x, object y)
    {
        if (x == y)
        {
            return true;
        }

        if (x == null || y == null)
        {
            return false;
        }

        if (x is global::C a
            && y is global::C b)
        {
            return Equals(a, b);
        }

        return x.Equals(y);
    }

    public int GetHashCode(object obj)
    {
        if (obj == null)
        {
            throw new ArgumentNullException(nameof(obj));
        }

        if (obj is C x)
        {
            return GetHashCode(x);
        }

        return obj.GetHashCode();
    }
}]]></After>
      </Sample>
    </Samples>
  </Analyzer>
</Analyzers>