C# ISymbol.GetAttributes方法代码示例

        public bool ContainedIn(ISymbol symbol)
        {
            bool result = false;
            var attributes = symbol.GetAttributes();
            foreach (var attribute in attributes)
            {
                INamedTypeSymbol attributeClass = attribute.AttributeClass;
                if (Uid != VisitorHelper.GetId(attributeClass))
                {
                    continue;
                }

                // arguments need to be a total match of the config
                IEnumerable<string> arguments = attribute.ConstructorArguments.Select(arg => GetLiteralString(arg));
                if (!ConstructorArguments.SequenceEqual(arguments))
                {
                    continue;
                }

                // namedarguments need to be a superset of the config
                Dictionary<string, string> namedArguments = attribute.NamedArguments.ToDictionary(pair => pair.Key, pair => GetLiteralString(pair.Value));
                if (!ConstructorNamedArguments.Except(namedArguments).Any())
                {
                    result = true;
                    break;
                }
            }

            return result;
        }

 public static IEnumerable<NameAndLocation> ItemsToIgnoreFromAttributes(ISymbol symbol,
                                                                        IEnumerable<Type> attributes) =>
     symbol.GetAttributes()
           .Where(a => attributes.TryFirst(t => MatchAttributeName(t, a.AttributeClass.Name)).HasValue)
           .SelectMany(attribute =>
                           (attribute.ApplicationSyntaxReference.GetSyntax() as AttributeSyntax).ArgumentList
                                                                                                .Arguments)
           .Select(argument => new NameAndLocation(argument.ToString().Trim('"'), argument.GetLocation()));

 public static AttributeData FindAttributeOfType(ISymbol typeSymbol, Type type)
 {
     foreach (AttributeData attributeData in typeSymbol.GetAttributes())
     {
         if (attributeData.AttributeClass.ToString() ==
             type.FullName)
         {
             return attributeData;
         }
     }
     return null;
 }

            internal static bool IsGeneratedSymbolWithGeneratedCodeAttribute(ISymbol symbol, INamedTypeSymbol generatedCodeAttribute)
            {
                Debug.Assert(symbol != null);
                Debug.Assert(generatedCodeAttribute != null);

                // GeneratedCodeAttribute can only be applied once on a symbol.
                // For partial symbols with more than one definition, we must treat them as non-generated code symbols.
                if (symbol.DeclaringSyntaxReferences.Length > 1)
                {
                    return false;
                }

                if (symbol.GetAttributes().Any(a => a.AttributeClass == generatedCodeAttribute))
                {
                    return true;
                }

                return symbol.ContainingSymbol != null && IsGeneratedSymbolWithGeneratedCodeAttribute(symbol.ContainingSymbol, generatedCodeAttribute);
            }

        /// <summary>
        /// Creates transform instances.
        /// </summary>
        /// <param name="symbol">The symbol to create from.</param>
        /// <returns>A collection of extensions.</returns>
        public IEnumerable<IExtension> GetExtensions(ISymbol symbol)
        {
            if (symbol == null)
                yield break;

            var attributes = symbol.GetAttributes();
            if (attributes == null)
                yield break;

            foreach (var attr in attributes)
            {
                // look for extension attribute
                var extAttr = attr.AttributeClass.GetAttributes()
                    .AsEnumerable().SingleOrDefault(aa =>
                        aa.AttributeClass.GetFullName() == _extClassName);

                if (extAttr == null)
                    continue;

                // handler class assembly and type names come from arguments of extension attribute
                var asmName = extAttr.ConstructorArguments.ElementAt(0).Value.ToString();
                var typeName = extAttr.ConstructorArguments.ElementAt(1).Value.ToString();

                // applied attribute arguments are passed directly to handler ctor
                var args = attr.ConstructorArguments.AsEnumerable().Select(p => p.Value);

                // create an instance of the handler class
                var instanceWrapper = Activator.CreateInstance(asmName, typeName, false, 0, null, args.ToArray(), null, null);
                var inst = instanceWrapper.Unwrap() as IExtension;

                if (inst == null)
                    throw new InvalidOperationException("Unable to create transform extension for: " + attr.AttributeClass.GetFullName());

                // support for named arguments (these bind to properties on the handler)
                foreach (var prop in attr.NamedArguments.AsEnumerable())
                    inst.GetType().GetProperty(prop.Key).SetValue(inst, prop.Value.Value, null);

                yield return inst;
            }
        }

 private ImmutableArray<AttributeData> GetRuleDependencyAttributes(ISymbol symbol, IEnumerable<INamedTypeSymbol> ruleDependencyAttributeTypes)
 {
     return GetRuleDependencyAttributes(symbol.GetAttributes(), ruleDependencyAttributeTypes);
 }

 private IEnumerable<SyntaxNode> GetSymbolAttributes(ISymbol symbol)
 {
     return symbol.GetAttributes().Select(a => Attribute(a));
 }

        private static void ParseClassSymbols(ParseResult disco, ISymbol symbol)
        {
            foreach (var attrData in symbol.GetAttributes())
            {
                var attrClassSymbol = attrData.AttributeClass;

                // handle errors
                if (attrClassSymbol is IErrorTypeSymbol) continue;
                if (attrData.AttributeConstructor == null) continue;

                var attrClassName = SymbolDisplay.ToDisplayString(attrClassSymbol);
                switch (attrClassName)
                {
                    case "Umbraco.ModelsBuilder.IgnorePropertyTypeAttribute":
                        var propertyAliasToIgnore = (string)attrData.ConstructorArguments[0].Value;
                        disco.SetIgnoredProperty(symbol.Name /*SymbolDisplay.ToDisplayString(symbol)*/, propertyAliasToIgnore);
                        break;
                    case "Umbraco.ModelsBuilder.RenamePropertyTypeAttribute":
                        var propertyAliasToRename = (string)attrData.ConstructorArguments[0].Value;
                        var propertyRenamed = (string)attrData.ConstructorArguments[1].Value;
                        disco.SetRenamedProperty(symbol.Name /*SymbolDisplay.ToDisplayString(symbol)*/, propertyAliasToRename, propertyRenamed);
                        break;
                    // that one causes all sorts of issues with references to Umbraco.Core in Roslyn
                    //case "Umbraco.Core.Models.PublishedContent.PublishedContentModelAttribute":
                    //    var contentAliasToRename = (string)attrData.ConstructorArguments[0].Value;
                    //    disco.SetRenamedContent(contentAliasToRename, symbol.Name /*SymbolDisplay.ToDisplayString(symbol)*/);
                    //    break;
                    case "Umbraco.ModelsBuilder.ImplementContentTypeAttribute":
                        var contentAliasToRename = (string)attrData.ConstructorArguments[0].Value;
                        disco.SetRenamedContent(contentAliasToRename, symbol.Name, true /*SymbolDisplay.ToDisplayString(symbol)*/);
                        break;
                }
            }
        }

            private async Task AddDescriptionPartAsync(ISymbol symbol)
            {
                if (symbol.GetAttributes().Any(x => x.AttributeClass.MetadataName == "ObsoleteAttribute"))
                {
                    AddDeprecatedPrefix();
                }

                if (symbol is IDynamicTypeSymbol)
                {
                    AddDescriptionForDynamicType();
                }
                else if (symbol is IFieldSymbol)
                {
                    await AddDescriptionForFieldAsync((IFieldSymbol)symbol).ConfigureAwait(false);
                }
                else if (symbol is ILocalSymbol)
                {
                    await AddDescriptionForLocalAsync((ILocalSymbol)symbol).ConfigureAwait(false);
                }
                else if (symbol is IMethodSymbol)
                {
                    AddDescriptionForMethod((IMethodSymbol)symbol);
                }
                else if (symbol is ILabelSymbol)
                {
                    AddDescriptionForLabel((ILabelSymbol)symbol);
                }
                else if (symbol is INamedTypeSymbol)
                {
                    await AddDescriptionForNamedTypeAsync((INamedTypeSymbol)symbol).ConfigureAwait(false);
                }
                else if (symbol is INamespaceSymbol)
                {
                    AddDescriptionForNamespace((INamespaceSymbol)symbol);
                }
                else if (symbol is IParameterSymbol)
                {
                    await AddDescriptionForParameterAsync((IParameterSymbol)symbol).ConfigureAwait(false);
                }
                else if (symbol is IPropertySymbol)
                {
                    AddDescriptionForProperty((IPropertySymbol)symbol);
                }
                else if (symbol is IRangeVariableSymbol)
                {
                    AddDescriptionForRangeVariable((IRangeVariableSymbol)symbol);
                }
                else if (symbol is ITypeParameterSymbol)
                {
                    AddDescriptionForTypeParameter((ITypeParameterSymbol)symbol);
                }
                else if (symbol is IAliasSymbol)
                {
                    await AddDescriptionPartAsync(((IAliasSymbol)symbol).Target).ConfigureAwait(false);
                }
                else
                {
                    AddDescriptionForArbitrarySymbol(symbol);
                }
            }

        private static void DecodeGlobalSuppressMessageAttributes(Compilation compilation, ISymbol symbol, ISymbol suppressMessageAttribute, GlobalSuppressions globalSuppressions)
        {
            Debug.Assert(symbol is IAssemblySymbol || symbol is IModuleSymbol);

            var attributeInstances = symbol.GetAttributes().Where(a => a.AttributeClass == suppressMessageAttribute);

            foreach (var instance in attributeInstances)
            {
                SuppressMessageInfo info;
                if (!TryDecodeSuppressMessageAttributeData(instance, out info))
                {
                    continue;
                }

                string scopeString = info.Scope != null ? info.Scope.ToLowerInvariant() : null;
                TargetScope scope;

                if (SuppressMessageScopeTypes.TryGetValue(scopeString, out scope))
                {
                    if ((scope == TargetScope.Module || scope == TargetScope.None) && info.Target == null)
                    {
                        // This suppression is applies to the entire compilation
                        globalSuppressions.AddCompilationWideSuppression(info.Id);
                        continue;
                    }
                }
                else
                {
                    // Invalid value for scope
                    continue;
                }

                // Decode Target
                if (info.Target == null)
                {
                    continue;
                }

                foreach (var target in ResolveTargetSymbols(compilation, info.Target, scope))
                {
                    globalSuppressions.AddGlobalSymbolSuppression(target, info.Id);
                }
            }
        }

        private void DecodeGlobalSuppressMessageAttributes(Compilation compilation, ISymbol symbol, GlobalSuppressions globalSuppressions)
        {
            Debug.Assert(symbol is IAssemblySymbol || symbol is IModuleSymbol);

            var attributes = symbol.GetAttributes().Where(a => a.AttributeClass == this.SuppressMessageAttribute);
            DecodeGlobalSuppressMessageAttributes(compilation, symbol, globalSuppressions, attributes);
        }

		static bool IsObsolete (ISymbol symbol)
		{
			return symbol.GetAttributes ().Any (attr => attr.AttributeClass.Name == "ObsoleteAttribute" && attr.AttributeClass.ContainingNamespace.GetFullName () == "System");
		}

            private static string GetNewFieldName(ISymbol fieldSymbol)
            {
                var name = fieldSymbol.Name.Trim('_');
                if (name.Length > 2 && char.IsLetter(name[0]) && name[1] == '_')
                {
                    name = name.Substring(2);
                }

                // Some .NET code uses "ts_" prefix for thread static
                if (name.Length > 3 && name.StartsWith("ts_", StringComparison.OrdinalIgnoreCase))
                {
                    name = name.Substring(3);
                }

                if (name.Length == 0)
                {
                    return fieldSymbol.Name;
                }

                if (name.Length > 2 && char.IsUpper(name[0]) && char.IsLower(name[1]))
                {
                    name = char.ToLower(name[0]) + name.Substring(1);
                }

                if (fieldSymbol.IsStatic)
                {
                    // Check for ThreadStatic private fields.
                    if (fieldSymbol.GetAttributes().Any(a => a.AttributeClass.Name.Equals("ThreadStaticAttribute", StringComparison.Ordinal)))
                    {
                        return "t_" + name;
                    }
                    else
                    {
                        return "s_" + name;
                    }
                }

                return "_" + name;
            }

 public static bool IsRemovable(ISymbol symbol, Accessibility maxAccessibility)
 {
     return symbol != null &&
         EffectiveAccessibility(symbol) <= maxAccessibility &&
         !symbol.IsImplicitlyDeclared &&
         !symbol.IsAbstract &&
         !symbol.IsVirtual &&
         !symbol.GetAttributes().Any() &&
         !symbol.ContainingType.IsInterface() &&
         !symbol.IsInterfaceImplementationOrMemberOverride();
 }

        private void AnalyzeSymbol(Action<Diagnostic> reportDiagnostic, ISymbol symbol)
        {
            var attributes = symbol.GetAttributes();

            foreach (var attribute in attributes)
            {
                Analyze(reportDiagnostic, attribute);
            }
        }