C# SonarAnalysisContext.RegisterSymbolAction方法代码示例

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = c.Symbol as INamedTypeSymbol;
                    if (!namedType.IsClass())
                    {
                        return;
                    }

                    CheckClasses(namedType, c);
                    CheckConstructors(namedType, c);
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (!namedType.IsClassOrStruct())
                    {
                        return;
                    }

                    foreach (var methodSymbol in namedType.GetMembers().OfType<IMethodSymbol>())
                    {
                        ReportUnusedParametersOnMethod(methodSymbol, c);
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (!namedType.IsClassOrStruct() ||
                        namedType.ContainingType != null)
                    {
                        return;
                    }

                    var removableDeclarationCollector = new RemovableDeclarationCollector(namedType, c.Compilation);

                    var candidateFields = removableDeclarationCollector.GetRemovableFieldLikeDeclarations(
                        ImmutableHashSet.Create(SyntaxKind.FieldDeclaration), maxAccessibility)
                        .Where(tuple => !IsInitializedOrFixed(((VariableDeclaratorSyntax)tuple.SyntaxNode)));

                    var candidateProperties = removableDeclarationCollector.GetRemovableDeclarations(
                        ImmutableHashSet.Create(SyntaxKind.PropertyDeclaration), maxAccessibility)
                        .Where(tuple => IsAutoPropertyWithNoInitializer((PropertyDeclarationSyntax)tuple.SyntaxNode));

                    var allCandidateMembers = candidateFields.Concat(candidateProperties).ToList();
                    if (!allCandidateMembers.Any())
                    {
                        return;
                    }

                    var usedMembers = GetMemberUsages(removableDeclarationCollector, new HashSet<ISymbol>(allCandidateMembers.Select(t => t.Symbol)));
                    var usedMemberSymbols = new HashSet<ISymbol>(usedMembers.Select(tuple => tuple.Symbol));

                    var assignedMemberSymbols = GetAssignedMemberSymbols(usedMembers);

                    foreach (var candidateMember in allCandidateMembers)
                    {
                        if (!usedMemberSymbols.Contains(candidateMember.Symbol))
                        {
                            /// reported by <see cref="UnusedPrivateMember"/>
                            continue;
                        }

                        if (!assignedMemberSymbols.Contains(candidateMember.Symbol))
                        {
                            var field = candidateMember.SyntaxNode as VariableDeclaratorSyntax;
                            var property = candidateMember.SyntaxNode as PropertyDeclarationSyntax;

                            var memberType = field != null ? "field" : "auto-property";

                            var location = field != null
                                ? field.Identifier.GetLocation()
                                : property.Identifier.GetLocation();

                            c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule, location, memberType, candidateMember.Symbol.Name));
                        }
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (!namedType.IsClassOrStruct() ||
                        namedType.ContainingType != null)
                    {
                        return;
                    }

                    var removableDeclarationCollector = new RemovableDeclarationCollector(namedType, c.Compilation);

                    var removableEvents = removableDeclarationCollector.GetRemovableDeclarations(
                        ImmutableHashSet.Create(SyntaxKind.EventDeclaration), maxAccessibility);
                    var removableEventFields = removableDeclarationCollector.GetRemovableFieldLikeDeclarations(
                        ImmutableHashSet.Create(SyntaxKind.EventFieldDeclaration), maxAccessibility);

                    var allRemovableEvents = removableEvents.Concat(removableEventFields).ToList();
                    if (!allRemovableEvents.Any())
                    {
                        return;
                    }

                    var symbolNames = allRemovableEvents.Select(t => t.Symbol.Name).ToImmutableHashSet();
                    var usedSymbols = GetReferencedSymbolsWithMatchingNames(removableDeclarationCollector, symbolNames);
                    var invokedSymbols = GetInvokedEventSymbols(removableDeclarationCollector);
                    var possiblyCopiedSymbols = GetPossiblyCopiedSymbols(removableDeclarationCollector);

                    foreach (var removableEvent in allRemovableEvents)
                    {
                        if (!usedSymbols.Contains(removableEvent.Symbol))
                        {
                            /// reported by <see cref="UnusedPrivateMember"/>
                            continue;
                        }

                        if (!invokedSymbols.Contains(removableEvent.Symbol) &&
                            !possiblyCopiedSymbols.Contains(removableEvent.Symbol))
                        {
                            var eventField = removableEvent.SyntaxNode as VariableDeclaratorSyntax;
                            var location = eventField != null
                                ? eventField.Identifier.GetLocation()
                                : ((EventDeclarationSyntax)removableEvent.SyntaxNode).Identifier.GetLocation();

                            c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule, location));
                        }
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (namedType.ContainingType != null ||
                        !namedType.IsClassOrStruct())
                    {
                        return;
                    }

                    var typesDeclarationsAndSemanticModels =
                        namedType.DeclaringSyntaxReferences
                        .Select(r => new SyntaxNodeSemanticModelTuple<SyntaxNode>
                        {
                            SyntaxNode = r.GetSyntax(),
                            SemanticModel = c.Compilation.GetSemanticModel(r.SyntaxTree)
                        })
                        .ToList();

                    var trackedNodesAndSymbols = new HashSet<NodeAndSymbol>();
                    foreach (var typeDeclarationAndSemanticModel in typesDeclarationsAndSemanticModels)
                    {
                        TrackInitializedLocalsAndPrivateFields(typeDeclarationAndSemanticModel.SyntaxNode, typeDeclarationAndSemanticModel.SemanticModel, trackedNodesAndSymbols);
                        TrackAssignmentsToLocalsAndPrivateFields(typeDeclarationAndSemanticModel.SyntaxNode, typeDeclarationAndSemanticModel.SemanticModel, trackedNodesAndSymbols);
                    }

                    if (trackedNodesAndSymbols.Any())
                    {
                        var excludedSymbols = new HashSet<ISymbol>();
                        foreach (var typeDeclarationAndSemanticModel in typesDeclarationsAndSemanticModels)
                        {
                            ExcludeDisposedAndClosedLocalsAndPrivateFields(typeDeclarationAndSemanticModel.SyntaxNode, typeDeclarationAndSemanticModel.SemanticModel, excludedSymbols);
                            ExcludeReturnedPassedAndAliasedLocalsAndPrivateFields(typeDeclarationAndSemanticModel.SyntaxNode, typeDeclarationAndSemanticModel.SemanticModel, excludedSymbols);
                        }

                        foreach (var trackedNodeAndSymbol in trackedNodesAndSymbols)
                        {
                            if (!excludedSymbols.Contains(trackedNodeAndSymbol.Symbol))
                            {
                                c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule, trackedNodeAndSymbol.Node.GetLocation(), trackedNodeAndSymbol.Symbol.Name), c.Compilation);
                            }
                        }
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (!namedType.IsClassOrStruct() ||
                        namedType.ContainingType != null)
                    {
                        return;
                    }

                    var declarationCollector = new RemovableDeclarationCollector(namedType, c.Compilation);

                    var declaredPrivateSymbols = new HashSet<ISymbol>();
                    var fieldLikeSymbols = new BidirectionalDictionary<ISymbol, SyntaxNode>();

                    CollectRemovableNamedTypes(declarationCollector, declaredPrivateSymbols);
                    CollectRemovableFieldLikeDeclarations(declarationCollector, declaredPrivateSymbols, fieldLikeSymbols);
                    CollectRemovableEventsAndProperties(declarationCollector, declaredPrivateSymbols);
                    CollectRemovableMethods(declarationCollector, declaredPrivateSymbols);

                    if (!declaredPrivateSymbols.Any())
                    {
                        return;
                    }

                    var usedSymbols = new HashSet<ISymbol>();
                    var emptyConstructors = new HashSet<ISymbol>();

                    CollectUsedSymbols(declarationCollector, usedSymbols, declaredPrivateSymbols);
                    CollectUsedSymbolsFromCtorInitializerAndCollectEmptyCtors(declarationCollector,
                        usedSymbols, emptyConstructors);

                    ReportIssues(c, usedSymbols, declaredPrivateSymbols, emptyConstructors, fieldLikeSymbols);
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var declaredSymbol = (INamedTypeSymbol)c.Symbol;
                    if (!declaredSymbol.IsClassOrStruct())
                    {
                        return;
                    }

                    if (declaredSymbol.DeclaringSyntaxReferences.Count() > 1)
                    {
                        // Partial classes are not processed.
                        // See https://github.com/dotnet/roslyn/issues/3748
                        return;
                    }

                    var partialDeclarations = declaredSymbol.DeclaringSyntaxReferences
                        .Select(reference => reference.GetSyntax())
                        .OfType<TypeDeclarationSyntax>()
                        .Select(node =>
                            new SyntaxNodeSemanticModelTuple<TypeDeclarationSyntax>
                            {
                                SyntaxNode = node,
                                SemanticModel = c.Compilation.GetSemanticModel(node.SyntaxTree)
                            })
                        .Where(n => n.SemanticModel != null);

                    var fieldCollector = new ReadonlyFieldCollector(partialDeclarations);

                    foreach (var field in fieldCollector.NonCompliantFields)
                    {
                        var identifier = field.SyntaxNode.Identifier;
                        c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule, identifier.GetLocation(), identifier.ValueText));
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (!namedType.IsClassOrStruct() ||
                        namedType.ContainingType != null)
                    {
                        return;
                    }

                    var removableDeclarationCollector = new RemovableDeclarationCollector(namedType, c.Compilation);

                    var declaredPrivateMethodsWithReturn = CollectRemovableMethods(removableDeclarationCollector).ToList();
                    if (!declaredPrivateMethodsWithReturn.Any())
                    {
                        return;
                    }

                    var invocations = CollectInvocations(removableDeclarationCollector.ClassDeclarations).ToList();

                    foreach (var declaredPrivateMethodWithReturn in declaredPrivateMethodsWithReturn)
                    {
                        var matchingInvocations = invocations
                            .Where(inv => object.Equals(inv.Symbol.OriginalDefinition, declaredPrivateMethodWithReturn.Symbol))
                            .ToList();

                        if (!matchingInvocations.Any())
                        {
                            /// this is handled by S1144 <see cref="UnusedPrivateMember"/>
                            continue;
                        }

                        if (!IsReturnValueUsed(matchingInvocations))
                        {
                            c.ReportDiagnostic(Diagnostic.Create(Rule, declaredPrivateMethodWithReturn.SyntaxNode.ReturnType.GetLocation()));
                        }
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var symbol = c.Symbol as INamedTypeSymbol;
                    if (!symbol.IsClass() ||
                        !symbol.IsAbstract ||
                        ClassHasInheritedAbstractMembers(symbol))
                    {
                        return;
                    }

                    if (AbstractClassShouldBeInterface(symbol))
                    {
                        ReportClass(symbol, MessageToInterface, c);
                        return;
                    }

                    if (AbstractClassShouldBeConcreteClass(symbol))
                    {
                        ReportClass(symbol, MessageToConcreteClass, c);
                        return;
                    }
                },
                SymbolKind.NamedType);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var namedType = (INamedTypeSymbol)c.Symbol;
                    if (namedType.Is(TypeKind.Struct))
                    {
                        return;
                    }

                    var hasServiceContract = HasServiceContract(namedType);
                    var hasAnyMethodWithOperationContract = HasAnyMethodWithoperationContract(namedType);

                    if (!(hasServiceContract ^ hasAnyMethodWithOperationContract))
                    {
                        return;
                    }

                    var declarationSyntax = GetTypeDeclaration(namedType, c.Compilation);
                    if (declarationSyntax == null)
                    {
                        return;
                    }

                    string message;
                    string attributeToAdd;

                    if (hasServiceContract)
                    {
                        message = MessageOperation;
                        attributeToAdd = "OperationContract";
                    }
                    else
                    {
                        message = MessageService;
                        attributeToAdd = "ServiceContract";
                    }

                    var classOrInterface = namedType.IsClass() ? "class" : "interface";
                    message = string.Format(message, classOrInterface);

                    c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule,
                        declarationSyntax.Identifier.GetLocation(), attributeToAdd, message));
                },
                SymbolKind.NamedType);
        }

 protected override void Initialize(SonarAnalysisContext context)
 {
     context.RegisterSymbolAction(
         c => CheckClassWithOnlyUnusedPrivateConstructors(c),
         SymbolKind.NamedType);
 }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var methodSymbol = c.Symbol as IMethodSymbol;
                    if (methodSymbol == null ||
                        methodSymbol.IsInterfaceImplementationOrMemberOverride() ||
                        !methodSymbol.Parameters.Any(p => p.IsOptional))
                    {
                        return;
                    }

                    var methods = methodSymbol.ContainingType.GetMembers(methodSymbol.Name)
                        .OfType<IMethodSymbol>();

                    var hidingInfos = new List<ParameterHidingMethodInfo>();

                    var matchingNamedMethods = methods
                        .Where(m => m.Parameters.Length < methodSymbol.Parameters.Length)
                        .Where(m => !m.Parameters.Any(p => p.IsParams));

                    foreach (var candidateHidingMethod in matchingNamedMethods
                        .Where(candidateHidingMethod => IsMethodHidingOriginal(candidateHidingMethod, methodSymbol))
                        .Where(candidateHidingMethod => methodSymbol.Parameters[candidateHidingMethod.Parameters.Length].IsOptional))
                    {
                        hidingInfos.Add(
                            new ParameterHidingMethodInfo
                            {
                                ParameterToReportOn = methodSymbol.Parameters[candidateHidingMethod.Parameters.Length],
                                HiddenMethod = methodSymbol,
                                HidingMethod = candidateHidingMethod
                            });
                    }

                    foreach (var hidingInfo in hidingInfos)
                    {
                        var syntax = hidingInfo.ParameterToReportOn.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax();
                        if (syntax == null)
                        {
                            continue;
                        }

                        var hidingMethod = hidingInfo.HidingMethod;
                        if (hidingMethod.PartialImplementationPart != null)
                        {
                            hidingMethod = hidingMethod.PartialImplementationPart;
                        }

                        var hidingMethodSyntax = hidingMethod.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax();
                        if (hidingMethodSyntax == null)
                        {
                            continue;
                        }

                        var defaultCanBeUsed =
                            IsMoreParameterAvailableInConflicting(hidingInfo) ||
                            !MethodsUsingSameParameterNames(hidingInfo);

                        var isOtherFile = syntax.SyntaxTree.FilePath != hidingMethodSyntax.SyntaxTree.FilePath;

                        c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule, syntax.GetLocation(),
                            hidingMethodSyntax.GetLocation().GetLineSpan().StartLinePosition.Line + 1,
                            isOtherFile
                                ? $" in file \"{new FileInfo(hidingMethodSyntax.SyntaxTree.FilePath).Name}\""
                                : string.Empty,
                            defaultCanBeUsed
                                ? "can only be used with named arguments"
                                : "can't be used"));
                    }
                },
                SymbolKind.Method);
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterSymbolAction(
                c =>
                {
                    var declaredSymbol = (INamedTypeSymbol)c.Symbol;

                    if (declaredSymbol.DeclaringSyntaxReferences.Count() > 1)
                    {
                        // Partial classes are not processed.
                        // See https://github.com/dotnet/roslyn/issues/3748
                        return;
                    }

                    var disposeMethod = GetDisposeMethod(c.Compilation);
                    if (disposeMethod == null)
                    {
                        return;
                    }

                    var mightImplementDispose = new HashSet<IMethodSymbol>();
                    var namedDispose = new HashSet<IMethodSymbol>();

                    var methods = declaredSymbol.GetMembers(DisposeMethodName).OfType<IMethodSymbol>();
                    foreach (var method in methods)
                    {
                        CollectMethodsNamedAndImplementingDispose(method, disposeMethod, namedDispose, mightImplementDispose);
                    }

                    var disposeMethodsCalledFromDispose = new HashSet<IMethodSymbol>();
                    CollectInvocationsFromDisposeImplementation(disposeMethod, c.Compilation, mightImplementDispose, disposeMethodsCalledFromDispose);

                    ReportDisposeMethods(
                        namedDispose.Except(mightImplementDispose).Where(m => !disposeMethodsCalledFromDispose.Contains(m)),
                        c);
                },
                SymbolKind.NamedType);
        }