C# CompilationStartAnalysisContext.RegisterSymbolAction方法代码示例

        private void AnalyzeCompilationStart(CompilationStartAnalysisContext csContext)
        {
            // Get named type symbols for targetted exception types
            ImmutableHashSet<INamedTypeSymbol> exceptionTypes = s_exceptionTypeNames
                .Select(name => csContext.Compilation.GetTypeByMetadataName(name))
                .Where(t => t != null)
                .ToImmutableHashSet();

            if (!exceptionTypes.IsEmpty)
            {
                // register symbol action for named types
                csContext.RegisterSymbolAction(saContext =>
                {
                    var symbol = (INamedTypeSymbol)saContext.Symbol;

                    // skip public symbols
                    if (symbol.IsPublic()) return;

                    // only report if base type matches 
                    if (symbol.BaseType != null && exceptionTypes.Contains(symbol.BaseType))
                    {
                        saContext.ReportDiagnostic(symbol.CreateDiagnostic(Rule));
                    }
                },
                SymbolKind.NamedType);
            }
        }

        private static void AnalyzeCompilationStart(CompilationStartAnalysisContext context)
        {
            ImmutableHashSet<INamedTypeSymbol> badBaseTypes = s_badBaseTypesToMessage.Keys
                                .Select(bt => context.Compilation.GetTypeByMetadataName(bt))
                                .Where(bt => bt != null)
                                .ToImmutableHashSet();

            if (badBaseTypes.Count > 0)
            {
                context.RegisterSymbolAction((saContext) =>
                    {
                        var namedTypeSymbol = saContext.Symbol as INamedTypeSymbol;

                        if (namedTypeSymbol.BaseType != null && badBaseTypes.Contains(namedTypeSymbol.BaseType))
                        {
                            string baseTypeName = namedTypeSymbol.BaseType.ToDisplayString();
                            Debug.Assert(s_badBaseTypesToMessage.ContainsKey(baseTypeName));
                            string message = string.Format(s_badBaseTypesToMessage[baseTypeName], namedTypeSymbol.ToDisplayString(), baseTypeName);
                            Diagnostic diagnostic = Diagnostic.Create(Rule, namedTypeSymbol.Locations.First(), namedTypeSymbol.Locations.Skip(1), message);
                            saContext.ReportDiagnostic(diagnostic);
                        }
                    }
                    , SymbolKind.NamedType);
            }
        }

 private void InitializeCore(CompilationStartAnalysisContext context)
 {
     var objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
     var equatableType = context.Compilation.GetTypeByMetadataName(IEquatableMetadataName);
     if (objectType != null && equatableType != null)
     {
         context.RegisterSymbolAction(c => AnalyzeSymbol(c, objectType, equatableType), SymbolKind.NamedType);
     }
 }

 private static void OnCompilationStart(CompilationStartAnalysisContext context)
 {
     INamedTypeSymbol objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
     INamedTypeSymbol equatableType = context.Compilation.GetTypeByMetadataName(IEquatableMetadataName);
     if (objectType != null && equatableType != null)
     {
         context.RegisterSymbolAction(c => AnalyzeSymbol(c, equatableType), SymbolKind.NamedType);
     }
 }

 private void AnalyzeCompilationSymbol(CompilationStartAnalysisContext context)
 {
     _exceptionType = context.Compilation.GetTypeByMetadataName("System.Exception");
     // Analyze named types 
     context.RegisterSymbolAction(symbolContext =>
     {
         AnalyzeSymbol(symbolContext);
     }, SymbolKind.NamedType);
 }

        public override void OnCompilationStart(CompilationStartAnalysisContext context)
        {
            // Read the file line-by-line to get the terms.
            var additionalAnalyzerFiles = context.Options.AdditionalFiles.Where(af => af.Path.IndexOf(s_analyzerName, 0, StringComparison.OrdinalIgnoreCase) >= 0);

            if (!additionalAnalyzerFiles.Any())
                return;

            lock (_apisToEnsureExist)
            {
                foreach (string api in ReadRequiredAPIsFromFiles(additionalAnalyzerFiles))
                {
                    _apisToEnsureExist.Add(api);
                }
            }

            context.RegisterCompilationEndAction(OnCompilationEnd);
            context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method, SymbolKind.Event);
            context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Field, SymbolKind.Event);
        }

        private void OnCompilationStart(CompilationStartAnalysisContext context)
        {
            _candidateReadonlyFields = new HashSet<IFieldSymbol>();
            _writtenFields = new HashSet<IFieldSymbol>();

            _internalsVisibleToAttribute = context.Compilation.GetTypeByMetadataName(
                                                "System.Runtime.CompilerServices.InternalsVisibleToAttribute");

            context.RegisterSymbolAction(LocateCandidateReadonlyFields, SymbolKind.Field);
            context.RegisterSyntaxNodeAction(CheckForAssignment, s_compoundAssignmentExpressionKinds);
            context.RegisterSyntaxNodeAction(CheckForRefOrOutParameter, SyntaxKind.Argument);
            context.RegisterSyntaxNodeAction(CheckForExternMethodWithRefParameters, SyntaxKind.MethodDeclaration);
            context.RegisterSyntaxNodeAction(CheckForExternIndexer, SyntaxKind.IndexerDeclaration);
            context.RegisterSyntaxNodeAction(CheckForInvocations, SyntaxKind.InvocationExpression);
            context.RegisterCompilationEndAction(ReportUnwrittenFields);
        }

        private void CompilationStartAction(CompilationStartAnalysisContext context)
        {
            var workspace = (context.Options as WorkspaceAnalyzerOptions)?.Workspace;
            var optionSet = (context.Options as WorkspaceAnalyzerOptions)?.Workspace.Options;
            var currentValue = optionSet.GetOption(SimplificationOptions.NamingPreferences, context.Compilation.Language);

            if (!string.IsNullOrEmpty(currentValue))
            {
                // Deserializing the naming preference info on every CompilationStart is expensive.
                // Instead, the diagnostic engine should listen for option changes and have the
                // ability to create the new SerializableNamingStylePreferencesInfo when it detects
                // any change. The overall system would then only deserialize & allocate when 
                // actually necessary.
                var viewModel = SerializableNamingStylePreferencesInfo.FromXElement(XElement.Parse(currentValue));
                var preferencesInfo = viewModel.GetPreferencesInfo();
                context.RegisterSymbolAction(
                    symbolContext => SymbolAction(symbolContext, preferencesInfo),
                    _symbolKinds);
            }
        }

        //creates an instance of a class to perform the analysis statefully, and registers for various actions
        private void SetupAnalysis(CompilationStartAnalysisContext context)
        {
            //state collector
            CompilationAnalyzer compilationAnalyzer = new CompilationAnalyzer();

            //collects all class, method, field, and property symbols as state
            context.RegisterSymbolAction(compilationAnalyzer.AddClass, SymbolKind.NamedType);
            context.RegisterSymbolAction(compilationAnalyzer.AddMethod, SymbolKind.Method);
            context.RegisterSymbolAction(compilationAnalyzer.AddField, SymbolKind.Field);
            context.RegisterSymbolAction(compilationAnalyzer.AddProperty, SymbolKind.Property);

            //analyzes the state that has been collected
            context.RegisterCompilationEndAction(compilationAnalyzer.ReportCompilationEndDiagnostics);
        }

        private void OnCompilationStart(CompilationStartAnalysisContext compilationContext)
        {
            var additionalFiles = compilationContext.Options.AdditionalFiles;
            if (!_extraAdditionalFiles.IsDefaultOrEmpty)
            {
                additionalFiles = additionalFiles.AddRange(_extraAdditionalFiles);
            }

            ApiData shippedData;
            ApiData unshippedData;
            if (!TryGetApiData(additionalFiles, compilationContext.CancellationToken, out shippedData, out unshippedData))
            {
                return;
            }

            List<Diagnostic> errors;
            if (!ValidateApiFiles(shippedData, unshippedData, out errors))
            {
                compilationContext.RegisterCompilationEndAction(context =>
                {
                    foreach (var cur in errors)
                    {
                        context.ReportDiagnostic(cur);
                    }
                });

                return;
            }

            var impl = new Impl(shippedData, unshippedData);
            compilationContext.RegisterSymbolAction(
                impl.OnSymbolAction,
                SymbolKind.NamedType,
                SymbolKind.Event,
                SymbolKind.Field,
                SymbolKind.Method);
            compilationContext.RegisterCompilationEndAction(impl.OnCompilationEnd);
        }

 public override void CreateAnalyzerWithinCompilation(CompilationStartAnalysisContext context)
 {
     context.RegisterSymbolAction(
         (symbolContext) =>
         {
             symbolContext.ReportDiagnostic(Diagnostic.Create(Warning01, symbolContext.Symbol.Locations.First()));
         },
         SymbolKind.NamedType);
 }

 public override void OnCompilationStart(CompilationStartAnalysisContext obj)
 {
     _allowedPinvokeFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).Contains("PinvokeAnalyzer_"));
     _exceptionFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).Contains("PinvokeAnalyzerExceptionList.analyzerdata"));
     obj.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);
 }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     Analyzer analyzer = new Analyzer(context.Compilation.GetOrCreateGeneratedDocumentCache());
     context.RegisterSymbolAction(analyzer.AnalyzeField, SymbolKind.Field);
 }

 public void Initialize(CompilationStartAnalysisContext context)
 {
     context.RegisterSymbolAction(AnalyzeNamedTypeSymbol, SymbolKind.NamedType);
     context.RegisterOperationBlockAction(AnalyzeOperationBlock);
 }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     Analyzer analyzer = new Analyzer(context.Compilation.GetOrCreateGeneratedDocumentCache());
     context.RegisterSymbolAction(analyzer.HandleMethodDeclaration, SymbolKind.Method);
     context.RegisterSyntaxNodeActionHonorExclusions(AnonymousFunctionExpressionAction, AnonymousFunctionExpressionKinds);
 }