C# Compilation.GetMetadataReference方法代码示例

        private IVsNavInfo CreateNavInfo(
            IAssemblySymbol containingAssembly,
            Project project,
            Compilation compilation,
            bool useExpandedHierarchy,
            string namespaceName = null,
            string className = null,
            string memberName = null)
        {
            Debug.Assert(containingAssembly != null);
            Debug.Assert(compilation != null);

            var portableExecutableReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;
            var assemblyName = portableExecutableReference != null
                ? portableExecutableReference.FilePath
                : containingAssembly.Identity.Name;

            var isReferencedAssembly = !containingAssembly.Identity.Equals(compilation.Assembly.Identity);

            // useExpandedHierarchy is true when references are nested inside the project by the
            // hierarchy. In Class View, they are nested in the Project References node. In Object Browser,
            // they are not.
            //
            // In the case that references are nested inside of the project, we need to create the nav info
            // differently:
            //
            //     project -> containing assembly -> namespace -> type
            //
            // Otherwise, we create it like so:
            //
            //     containing assembly -> namespace -> type

            var libraryName = isReferencedAssembly
                ? assemblyName
                : project.GetProjectNavInfoName();

            var metadataProjectItem = useExpandedHierarchy && isReferencedAssembly
                ? project.GetProjectNavInfoName()
                : null;

            return new NavInfo(
                this.LibraryGuid,
                this.SymbolToolLanguage,
                libraryName,
                metadataProjectItem,
                namespaceName,
                className,
                memberName);
        }

        private static string GetLocationString(Compilation compilation, Symbol unwrappedSymbol)
        {
            Debug.Assert((object)unwrappedSymbol == UnwrapSymbol(unwrappedSymbol));

            ImmutableArray<SyntaxReference> syntaxReferences = unwrappedSymbol.DeclaringSyntaxReferences;
            if (syntaxReferences.Length > 0)
            {
                var tree = syntaxReferences[0].SyntaxTree;
                var span = syntaxReferences[0].Span;
                string path = tree.GetDisplayPath(span, (compilation != null) ? compilation.Options.SourceReferenceResolver : null);
                if (!string.IsNullOrEmpty(path))
                {
                    return $"{path}({tree.GetDisplayLineNumber(span)})";
                }
            }

            AssemblySymbol containingAssembly = unwrappedSymbol.ContainingAssembly;
            if ((object)containingAssembly != null)
            {
                if (compilation != null)
                {
                    PortableExecutableReference metadataReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;
                    if (metadataReference != null)
                    {
                        string path = metadataReference.FilePath;
                        if (!string.IsNullOrEmpty(path))
                        {
                            return path;
                        }
                    }
                }

                return containingAssembly.Identity.ToString();
            }

            Debug.Assert(unwrappedSymbol.Kind == SymbolKind.DynamicType || unwrappedSymbol.Kind == SymbolKind.ErrorType);
            return null;
        }

        private IVsNavInfo Create(IAssemblySymbol containingAssembly, Project project, Compilation compilation, bool useExpandedHierarchy = false,
            string namespaceName = null, string className = null, string memberName = null)
        {
            // useExpandedHierarchy is true when references are nested inside the project by the
            // hierarchy. In Class View, they are nested in the Project References node. In Object Browser,
            // they are not.
            //
            // In the case that references are nested inside of the project, we need to create the nav info
            // differently:
            //
            //     project -> containing assembly -> namespace -> type
            //
            // Otherwise, we create it like so:
            //
            //     containing assembly -> namespace -> type

            string libraryName;
            string referenceOwnerName = null;

            var isCompilationAssembly = containingAssembly.Identity.Equals(compilation.Assembly.Identity);
            if (isCompilationAssembly)
            {
                libraryName = GetLibraryName(project);
            }
            else
            {
                var portableExecutableReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;

                libraryName = portableExecutableReference != null
                    ? portableExecutableReference.FilePath
                    : containingAssembly.Identity.Name;

                if (useExpandedHierarchy)
                {
                    referenceOwnerName = GetLibraryName(project);
                }
            }

            return Create(libraryName, referenceOwnerName, namespaceName, className, memberName);
        }