C# INamedTypeSymbol.GetSymbolKey方法代码示例

        private static async Task GetDependentTypesInProjectAsync(
            INamedTypeSymbol type, Project project, Solution solution, Func<INamedTypeSymbol, INamedTypeSymbol, bool> predicate, ConditionalWeakTable<Compilation, ConcurrentDictionary<SymbolKey, List<SymbolKey>>> cache, bool locationsInMetadata, ConcurrentSet<ISymbol> results, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

            var typeId = type.GetSymbolKey();

            List<SymbolKey> dependentTypeIds;
            if (!TryGetDependentTypes(cache, compilation, typeId, out dependentTypeIds))
            {
                List<INamedTypeSymbol> allTypes;
                if (locationsInMetadata)
                {
                    // From metadata, have to check other (non private) metadata types, as well as
                    // source types.
                    allTypes = GetAllSourceAndAccessibleTypesInCompilation(compilation, cancellationToken);
                }
                else
                {
                    // It's from source, so only other source types could derive from it.
                    allTypes = GetAllSourceTypesInCompilation(compilation, cancellationToken);
                }

                dependentTypeIds = new List<SymbolKey>();
                foreach (var t in allTypes)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    if (predicate(t, type))
                    {
                        dependentTypeIds.Add(t.GetSymbolKey());
                    }
                }

                dependentTypeIds = GetOrAddDependentTypes(cache, compilation, typeId, dependentTypeIds);
            }

            foreach (var id in dependentTypeIds)
            {
                cancellationToken.ThrowIfCancellationRequested();

                var resolvedSymbols = id.Resolve(compilation, cancellationToken: cancellationToken).GetAllSymbols();
                foreach (var resolvedSymbol in resolvedSymbols)
                {
                    var mappedSymbol = await SymbolFinder.FindSourceDefinitionAsync(resolvedSymbol, solution, cancellationToken).ConfigureAwait(false) ?? resolvedSymbol;
                    results.Add(mappedSymbol);
                }
            }
        }

            public override async Task<Document> GetUpdatedDocumentAsync(
                    Document document,
                    IList<Tuple<INamedTypeSymbol, IList<ISymbol>>> unimplementedMembers,
                    INamedTypeSymbol classOrStructType,
                    SyntaxNode classOrStructDecl,
                    CancellationToken cancellationToken)
            {
                var result = document;
                var compilation = await result.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

                // Add an annotation to the type declaration node so that we can find it again to append the dispose pattern implementation below.
                result = await result.ReplaceNodeAsync(
                    classOrStructDecl,
                    classOrStructDecl.WithAdditionalAnnotations(s_implementingTypeAnnotation),
                    cancellationToken).ConfigureAwait(false);
                var root = await result.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                classOrStructDecl = root.GetAnnotatedNodes(s_implementingTypeAnnotation).Single();
                compilation = await result.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                classOrStructType = classOrStructType.GetSymbolKey().Resolve(compilation, cancellationToken: cancellationToken).Symbol as INamedTypeSymbol;

                // Use the code generation service to generate all unimplemented members except those that are
                // part of the dispose pattern. We can't use the code generation service to implement the dispose
                // pattern since the code generation service doesn't support injection of the custom boiler
                // plate code required for implementing the dispose pattern.
                var idisposable = TryGetSymbolForIDisposable(compilation);
                result = await base.GetUpdatedDocumentAsync(
                                            result,
                                            unimplementedMembers.Where(m => !m.Item1.Equals(idisposable)).ToList(),
                                            classOrStructType,
                                            classOrStructDecl,
                                            cancellationToken).ConfigureAwait(false);

                // Now append the dispose pattern implementation.
                root = await result.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                classOrStructDecl = root.GetAnnotatedNodes(s_implementingTypeAnnotation).Single();
                compilation = await result.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                classOrStructType = classOrStructType.GetSymbolKey().Resolve(compilation, cancellationToken: cancellationToken).Symbol as INamedTypeSymbol;
                result = Service.ImplementDisposePattern(result, root, classOrStructType, classOrStructDecl.SpanStart, Explicitly);

                // Remove the annotation since we don't need it anymore.
                root = await result.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                classOrStructDecl = root.GetAnnotatedNodes(s_implementingTypeAnnotation).Single();
                result = await result.ReplaceNodeAsync(
                    classOrStructDecl,
                    classOrStructDecl.WithoutAnnotations(s_implementingTypeAnnotation),
                    cancellationToken).ConfigureAwait(false);

                return result;
            }