C# AnalysisContext.RegisterCodeBlockStartAction方法代码示例

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterCodeBlockStartAction<SyntaxKind>(
                cbc =>
                {
                    var methodDeclaration = cbc.CodeBlock as MethodDeclarationSyntax;

                    if (methodDeclaration == null || 
                        methodDeclaration.Identifier.Text != "ToString")
                    {
                        return;
                    }

                    cbc.RegisterSyntaxNodeAction(c =>
                    {
                        var returnStatement = (ReturnStatementSyntax)c.Node;

                        var nullExpression = returnStatement.Expression as LiteralExpressionSyntax;
                        if (nullExpression != null && nullExpression.IsKind(SyntaxKind.NullLiteralExpression))
                        {
                            c.ReportDiagnostic(Diagnostic.Create(Rule, returnStatement.GetLocation()));
                        }

                    }, SyntaxKind.ReturnStatement);
                });
        }        

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterCodeBlockStartAction<SyntaxKind>(startCodeBlockContext =>
            {
                // We only care about method bodies.
                if (startCodeBlockContext.OwningSymbol.Kind != SymbolKind.Method)
                {
                    return;
                }

                // We only care about methods with parameters.
                var method = (IMethodSymbol)startCodeBlockContext.OwningSymbol;
                if (method.Parameters.IsEmpty)
                {
                    return;
                }

                // Initialize local mutable state in the start action.
                var analyzer = new UnusedParametersAnalyzer(method);

                // Register an intermediate non-end action that accesses and modifies the state.
                startCodeBlockContext.RegisterSyntaxNodeAction(analyzer.AnalyzeSyntaxNode, SyntaxKind.IdentifierName);

                // Register an end action to report diagnostics based on the final state.
                startCodeBlockContext.RegisterCodeBlockEndAction(analyzer.CodeBlockEndAction);
            });
        }

 public override void Initialize(AnalysisContext c)
 {
     c.RegisterCodeBlockAction(b => ThrowIfMatch(nameof(c.RegisterCodeBlockAction), new AnalysisContextInfo(b.SemanticModel.Compilation, b.OwningSymbol, b.CodeBlock)));
     c.RegisterCodeBlockStartAction<SyntaxKind>(b => ThrowIfMatch(nameof(c.RegisterCodeBlockStartAction), new AnalysisContextInfo(b.SemanticModel.Compilation, b.OwningSymbol, b.CodeBlock)));
     c.RegisterCompilationAction(b => ThrowIfMatch(nameof(c.RegisterCompilationAction), new AnalysisContextInfo(b.Compilation)));
     c.RegisterCompilationStartAction(b => ThrowIfMatch(nameof(c.RegisterCompilationStartAction), new AnalysisContextInfo(b.Compilation)));
     c.RegisterOperationAction(b => ThrowIfMatch(nameof(c.RegisterOperationAction), new AnalysisContextInfo(b.Compilation, b.Operation)), OperationKind.ReturnStatement);
     c.RegisterOperationBlockAction(b => ThrowIfMatch(nameof(c.RegisterOperationBlockAction), new AnalysisContextInfo(b.Compilation, b.OwningSymbol)));
     c.RegisterSemanticModelAction(b => ThrowIfMatch(nameof(c.RegisterSemanticModelAction), new AnalysisContextInfo(b.SemanticModel)));
     c.RegisterSymbolAction(b => ThrowIfMatch(nameof(c.RegisterSymbolAction), new AnalysisContextInfo(b.Compilation, b.Symbol)), SymbolKind.NamedType);
     c.RegisterSyntaxNodeAction(b => ThrowIfMatch(nameof(c.RegisterSyntaxNodeAction), new AnalysisContextInfo(b.SemanticModel.Compilation, b.Node)), SyntaxKind.ReturnStatement);
     c.RegisterSyntaxTreeAction(b => ThrowIfMatch(nameof(c.RegisterSyntaxTreeAction), new AnalysisContextInfo(b.Compilation, b.Tree)));
 }

 public override void Initialize(AnalysisContext context)
 {
     if (_isCodeBlockAnalyzer)
     {
         context.RegisterCodeBlockStartAction<SyntaxKind>(OnCodeBlockStarted);
         context.RegisterCodeBlockAction(OnCodeBlockEnded);
     }
     else
     {
         Action<Action<SyntaxNodeAnalysisContext>, ImmutableArray<SyntaxKind>> registerMethod =
             (action, Kinds) => context.RegisterSyntaxNodeAction(action, Kinds);
         var analyzer = new NodeAnalyzer();
         analyzer.Initialize(registerMethod);
     }
 }

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterCodeBlockStartAction<SyntaxKind>(
                cbc =>
                {
                    SyntaxNode declaration = cbc.CodeBlock as MethodDeclarationSyntax;
                    var declarationType = "method";

                    if (declaration == null)
                    {
                        declaration = cbc.CodeBlock as AccessorDeclarationSyntax;
                        declarationType = "property";
                        if (declaration == null)
                        {
                            return;
                        }
                    }

                    var methodOrPropertySymbol = cbc.OwningSymbol;
                    if (methodOrPropertySymbol == null ||
                        methodOrPropertySymbol.IsStatic)
                    {
                        return;
                    }
                    
                    cbc.RegisterSyntaxNodeAction(
                    c =>
                    {
                        var assignment = (AssignmentExpressionSyntax)c.Node;
                        var expression = assignment.Left;

                        if (IsStaticFieldModification(expression, c.SemanticModel))
                        {
                            var location = Location.Create(expression.SyntaxTree,
                                new TextSpan(expression.SpanStart,
                                    assignment.OperatorToken.Span.End - expression.SpanStart));

                            c.ReportDiagnostic(Diagnostic.Create(Rule, location, declarationType));
                        }
                    },
                    SyntaxKind.SimpleAssignmentExpression,
                    SyntaxKind.AddAssignmentExpression,
                    SyntaxKind.SubtractAssignmentExpression,
                    SyntaxKind.MultiplyAssignmentExpression,
                    SyntaxKind.DivideAssignmentExpression,
                    SyntaxKind.ModuloAssignmentExpression,
                    SyntaxKind.AndAssignmentExpression,
                    SyntaxKind.ExclusiveOrAssignmentExpression,
                    SyntaxKind.OrAssignmentExpression,
                    SyntaxKind.LeftShiftAssignmentExpression,
                    SyntaxKind.RightShiftAssignmentExpression);

                    cbc.RegisterSyntaxNodeAction(
                        c =>
                        {
                            var unary = (PrefixUnaryExpressionSyntax)c.Node;
                            var expression = unary.Operand;

                            if (IsStaticFieldModification(expression, c.SemanticModel))
                            {
                                c.ReportDiagnostic(Diagnostic.Create(Rule, expression.GetLocation(), declarationType));
                            }
                        },
                        SyntaxKind.PreDecrementExpression,
                        SyntaxKind.PreIncrementExpression);

                    cbc.RegisterSyntaxNodeAction(
                        c =>
                        {
                            var unary = (PostfixUnaryExpressionSyntax)c.Node;
                            var expression = unary.Operand;

                            if (IsStaticFieldModification(expression, c.SemanticModel))
                            {
                                c.ReportDiagnostic(Diagnostic.Create(Rule, expression.GetLocation(), declarationType));
                            }
                        },
                        SyntaxKind.PostDecrementExpression,
                        SyntaxKind.PostIncrementExpression);
                });
        }

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterCodeBlockStartAction<SyntaxKind>(cbc =>
            {
                var unusedLocals = new List<ISymbol>();
 
                cbc.RegisterSyntaxNodeAction(c =>
                {
                    unusedLocals.AddRange(
                        ((LocalDeclarationStatementSyntax) c.Node).Declaration.Variables
                            .Select(variable => c.SemanticModel.GetDeclaredSymbol(variable))
                            .Where(symbol => symbol != null));
                },
                SyntaxKind.LocalDeclarationStatement);
 
                cbc.RegisterSyntaxNodeAction(c =>
                {
                    var symbolInfo = c.SemanticModel.GetSymbolInfo(c.Node);
                    unusedLocals.Remove(symbolInfo.Symbol);

                    foreach (var candidateSymbol in symbolInfo.CandidateSymbols)
                    {
                        unusedLocals.Remove(candidateSymbol);
                    }
                },
                SyntaxKind.IdentifierName);
 
                cbc.RegisterCodeBlockEndAction(c =>
                {
                    foreach (var unused in unusedLocals)
                    {
                        c.ReportDiagnostic(Diagnostic.Create(Rule, unused.Locations.First(), unused.Name));
                    }
                });
            });
        }

        public override void Initialize(AnalysisContext context)
        {
            context.RegisterCodeBlockStartAction<SyntaxKind>(
                cbc =>
                {
                    var calledVirtualMethods = ImmutableDictionary<InvocationExpressionSyntax, string>.Empty;

                    var constructorDeclaration = cbc.CodeBlock as ConstructorDeclarationSyntax;
                    if (constructorDeclaration == null)
                    {
                        return;
                    }

                    var constructorSymbol = cbc.SemanticModel.GetDeclaredSymbol(constructorDeclaration);
                    if (constructorSymbol == null)
                    {
                        return;
                    }

                    cbc.RegisterSyntaxNodeAction(
                        c =>
                        {
                            var invocationException = (InvocationExpressionSyntax) c.Node;
                            var methodSymbol =
                                c.SemanticModel.GetSymbolInfo(invocationException.Expression).Symbol as IMethodSymbol;
                            var enclosingSymbol = c.SemanticModel.GetEnclosingSymbol(invocationException.SpanStart);
                            if (methodSymbol == null ||
                                enclosingSymbol == null ||
                                !enclosingSymbol.Equals(constructorSymbol))
                            {
                                return;
                            }

                            if ((methodSymbol.IsVirtual ||
                                 methodSymbol.IsAbstract) &&
                                constructorSymbol.ContainingType.Equals(methodSymbol.ContainingType))
                            {
                                calledVirtualMethods = calledVirtualMethods.SetItem(invocationException,
                                    methodSymbol.Name);
                            }
                        },
                        SyntaxKind.InvocationExpression);

                    cbc.RegisterCodeBlockEndAction(
                        c =>
                        {
                            foreach (var calledVirtualMethod in calledVirtualMethods)
                            {
                                c.ReportDiagnostic(Diagnostic.Create(Rule, calledVirtualMethod.Key.Expression.GetLocation(),
                                    calledVirtualMethod.Value));
                            }
                        });
                });
        }

 public override void Initialize(AnalysisContext context)
 {
     context.RegisterCodeBlockStartAction<SyntaxKind>(CreateAnalyzerWithinCodeBlock);
 }

 public override void Initialize(AnalysisContext analysisContext)
 {
     if (_language == LanguageNames.CSharp)
     {
         analysisContext.RegisterCodeBlockStartAction<CSharp.SyntaxKind>(new CSharpCodeBodyAnalyzer().Initialize);
     }
     else
     {
         analysisContext.RegisterCodeBlockStartAction<VisualBasic.SyntaxKind>(new BasicCodeBodyAnalyzer().Initialize);
     }
 }

 public override void Initialize(AnalysisContext context)
 {
     context.RegisterCodeBlockStartAction<SyntaxKind>(new NodeAnalyzer().Initialize);
     context.RegisterCodeBlockEndAction(OnCodeBlockEnded);
 }