<PropertyGroup>
  <FxCopSdkDir>C:...Microsoft Fxcop 10.0</FxCopSdkDir>
</PropertyGroup>
<ItemGroup>
  <Reference Include="$(FxCopSdkDir)FxCopSdk.dll" />
  <Reference Include="$(FxCopSdkDir)Microsoft.CCi.dll" />
</ItemGroup>

<?xml version="1.0" encoding="utf-8" ?>
<Rules FriendlyName="Custom Rules">
  <Rule TypeName="DisallowStaticFieldsRule" 
    Category="Custom.Arbitrary" 
    CheckId="HP100">
  <Name>Static fields are not allowed</Name>
  <Description>Static fields are not allowed because...
  </Description>
  <Url>http://internaldocumentationsite/FxCop/HP100</Url>
  <Resolution>Make the static field '{0}' either 
   readonly or const.
  </Resolution>
  <MessageLevel Certainty="90">Error</MessageLevel>
  <FixCategories>Breaking</FixCategories>
  <Email>[email protected]</Email>
  <Owner>Ben Watson</Owner>
  </Rule>  
</Rules>

using Microsoft.FxCop.Sdk;
using System.Reflection;

namespace FxCopRules
{
  public abstract class BaseCustomRule : BaseIntrospectionRule
  {
    // The manifest name is the default namespace plus the name 
    // of the XML rules file, without the extension.
    private const string ManifestName = "FxCopRules.Rules";

    // The assembly where the rule manifest is 
    // embedded (the current assembly in our case).
    private static readonly Assembly ResourceAssembly =  
                      typeof(BaseCustomRule).Assembly;

    protected BaseCustomRule(string ruleName)
      :base(ruleName, ManifestName, ResourceAssembly)
    {
    }
  }
}

public class DisallowStaticFieldsRule : BaseCustomRule
{
  public DisallowStaticFieldsRule()
    : base(typeof(DisallowStaticFieldsRule).Name)
  {    
  }

  public override ProblemCollection Check(Member member)
  {
    var field = member as Field;
    if (field != null)
    {
      // Find all static data that isn't const or readonly
      if (field.IsStatic && !field.IsInitOnly && !field.IsLiteral)
      {
        // field.FullName is an optional argument that will be 
        // used to format the Resolution string's {0} parameter.
        var resolution = this.GetResolution(field.FullName);
        var problem = new Problem(resolution, 
                                  field.SourceContext);
        this.Problems.Add(problem);
      }
    }    
    return this.Problems;
  }     
}

public class DisallowStringCaseConversionRule : BaseCustomRule
{
  public DisallowStringCaseConversionRule()
    : base(typeof(DisallowStringCaseConversionRule).Name)
  { }

  public override ProblemCollection Check(Member member)
  {
    var method = member as Method;
    if (method != null)
    {
      foreach (var instruction in method.Instructions)
      {
        if (instruction.OpCode == OpCode.Call 
          || instruction.OpCode == OpCode.Calli 
          || instruction.OpCode == OpCode.Callvirt)
        {
          var targetMethod = instruction.Value as Method;
          if (targetMethod != null 
           && (targetMethod.FullName == "System.String.ToUpper" 
             || targetMethod.FullName == "System.String.ToLower"))
          {
            var resolution = this.GetResolution(method.FullName);
            var problem = new Problem(resolution, 
                          method.SourceContext);
            this.Problems.Add(problem);
          }
        }
      }
    }

    return this.Problems;
  }    
}

public class DisallowThreadCreationRule : BaseCustomRule
{
  public DisallowThreadCreationRule() 
     : base(typeof(DisallowThreadCreationRule).Name) { }

  public override ProblemCollection Check(Member member)
  {
    var method = member as Method;
    if (method != null)
    {
      VisitStatements(method.Body.Statements);
    }

    return base.Check(member);
  }

  public override void VisitConstruct(Construct construct)
  {
    if (construct != null)
    {
      var binding = construct.Constructor as MemberBinding;
      if (binding != null)
      {
        var instanceInitializer = 
              binding.BoundMember as InstanceInitializer;
        if (instanceInitializer.DeclaringType.FullName 
          == "System.Threading.Thread")
        {
          var problem = new Problem(this.GetResolution(), 
                        construct.SourceContext);
          this.Problems.Add(problem);
        }
      }
    }
    
    base.VisitConstruct(construct);
  }
}

using System.Collections.Immutable;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;

namespace SampleCodeAnalyzer
{
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public class StaticFieldAnalyzer : DiagnosticAnalyzer
    {
        public const string DiagnosticId = "StaticFieldAnalyzer";

        private static readonly LocalizableString Title = 
            new LocalizableResourceString(
                    nameof(Resources.AnalyzerTitle), 
                    Resources.ResourceManager, 
                    typeof(Resources));

        private static readonly LocalizableString MessageFormat = 
            new LocalizableResourceString(
                    nameof(Resources.AnalyzerMessageFormat), 
                    Resources.ResourceManager, 
                    typeof(Resources));

        private static readonly LocalizableString Description = 
            new LocalizableResourceString(
                    nameof(Resources.AnalyzerDescription), 
                    Resources.ResourceManager, 
                    typeof(Resources));

        private const string Category = "Thread Safety";

        private static DiagnosticDescriptor Rule = 
            new DiagnosticDescriptor(DiagnosticId, 
                                     Title, 
                                     MessageFormat, 
                                     Category, 
                                     DiagnosticSeverity.Info, 
                                     isEnabledByDefault: true, 
                                     description: Description);

        public override ImmutableArray<DiagnosticDescriptor> 
            SupportedDiagnostics 
        { 
            get 
            { 
                return ImmutableArray.Create(Rule); 
            }
        }

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterSymbolAction(AnalyzeFieldSymbol, 
                                         SymbolKind.Field);
        }

        private void AnalyzeFieldSymbol(
          SymbolAnalysisContext context)
        {
            IFieldSymbol field = (IFieldSymbol)context.Symbol;
            if (field.IsStatic && !field.IsReadOnly)
            {
                var diagnostic = Diagnostic.Create(
                                    Rule, 
                                    field.Locations[0], 
                                    field.Name);

                context.ReportDiagnostic(diagnostic);
            }
        }        
    }
}

using System.Collections.Immutable;
using System.Composition;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace SampleCodeAnalyzer
{
    [ExportCodeFixProvider(LanguageNames.CSharp, 
                           Name = nameof(StaticFieldFixer)), 
                           Shared]
    public class StaticFieldFixer : CodeFixProvider
    {
        private const string title = "Make readonly";

        public sealed override ImmutableArray<string> 
            FixableDiagnosticIds
        {
            get 
            { 
                return ImmutableArray.Create(
                    StaticFieldAnalyzer.DiagnosticId); 
            }
        }

        public sealed override FixAllProvider GetFixAllProvider()
        {
            return WellKnownFixAllProviders.BatchFixer;
        }

        public sealed override async Task RegisterCodeFixesAsync(
            CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(
                context.CancellationToken).ConfigureAwait(false);

            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;

            // Find the type declaration identified 
            // by the diagnostic.
            var declaration = root.FindToken(diagnosticSpan.Start)
                                .Parent.AncestorsAndSelf()
                                .OfType<FieldDeclarationSyntax>()
                                .First();

            // Register a code action that will invoke the fix.
            context.RegisterCodeFix(
                CodeAction.Create(
                    title: title,
                    createChangedDocument: 
                        c => MakeReadOnlyAsync(context.Document, 
                                               declaration, 
                                               c),
                    equivalenceKey: title),
                diagnostic);
        }

        private async Task<Document> MakeReadOnlyAsync(
            Document document, 
            FieldDeclarationSyntax fieldDecl, 
            CancellationToken cancellationToken)
        {
            // Find the field and update its modifiers
            var newFieldDecl = fieldDecl.AddModifiers(
                   SyntaxFactory.Token(
                     SyntaxKind.ReadOnlyKeyword));            

            var root = await document.GetSyntaxRootAsync();

            // Replace the node with a new one
            var newRoot = root.ReplaceNode(fieldDecl, 
                                           newFieldDecl);

            var newDocument = document.WithSyntaxRoot(newRoot);

            // Return the new solution with the 
            // now-uppercase type name.
            return newDocument;
        }
    }
}

using System.Collections.Immutable;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace SampleCodeAnalyzer
{
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public class StringToUpperToLowerAnalyzer : DiagnosticAnalyzer
    {
        public const string DiagnosticId = 
            "StringToUpperToLowerAnalyzer";
        
        private static readonly LocalizableString Title = 
          new LocalizableResourceString(
            nameof(Resources.ToUpperToLowerAnalyzerTitle), 
            Resources.ResourceManager, 
            typeof(Resources));

        private static readonly LocalizableString MessageFormat = 
          new LocalizableResourceString(
            nameof(Resources.ToUpperToLowerAnalyzerMessageFormat), 
            Resources.ResourceManager, 
            typeof(Resources));

        private static readonly LocalizableString Description = 
          new LocalizableResourceString(
            nameof(Resources.ToUpperToLowerAnalyzerDescription), 
            Resources.ResourceManager, 
            typeof(Resources));

        private const string Category = "Performance";

        private static DiagnosticDescriptor Rule = 
            new DiagnosticDescriptor(DiagnosticId, 
                                     Title, 
                                     MessageFormat, 
                                     Category, 
                                     DiagnosticSeverity.Warning, 
                                     isEnabledByDefault: true, 
                                     description: Description);

        public override ImmutableArray<DiagnosticDescriptor> 
            SupportedDiagnostics
        {
            get
            {
                return ImmutableArray.Create(Rule);
            }
        }

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterSyntaxNodeAction(
                AnalyzeNode, 
                SyntaxKind.InvocationExpression);
        }

        private void AnalyzeNode(
          SyntaxNodeAnalysisContext context)
        {
            var invocationExpression = 
                (InvocationExpressionSyntax)context.Node;
            var memberAccessExpression = 
                invocationExpression.Expression 
                   as MemberAccessExpressionSyntax;

            var memberName = 
              memberAccessExpression?.Name.ToString();
            if (memberName == "ToUpper" 
                || memberName == "ToLower")
            {
                var diagnostic = Diagnostic.Create(
                    Rule,
                    memberAccessExpression.GetLocation());

                context.ReportDiagnostic(diagnostic);
            }
        }
    }
}