Пример #1
0
        private void PopulateDependenciesFromPackagesConfig(ProjectDependencyInfo project, string packagesConfigPath)
        {
            if (!File.Exists(packagesConfigPath))
            {
                return;
            }

            var fileContent = File.ReadAllText(packagesConfigPath);

            var xel      = XElement.Parse(fileContent);
            var packages = xel.Elements()
                           .Where(l => l.Name.LocalName == "package")
                           .Select(el =>
            {
                var packageId      = el.Attributes().FirstOrDefault(a => a.Name.LocalName == "id")?.Value;
                var packageVersion = el.Attributes().FirstOrDefault(a => a.Name.LocalName == "version")?.Value;

                return(new Dependency
                {
                    Framework = project.FrameworkVersion,
                    Name = packageId,
                    Project = project.ProjectName,
                    Version = packageVersion,
                });
            });

            project.Dependencies = project.Dependencies.Concat(packages);
        }
Пример #2
0
        public Task <ProjectDependencyInfo> ReadProjectFile(string filename)
        {
            if (String.IsNullOrEmpty(filename))
            {
                throw new ArgumentNullException(nameof(filename));
            }

            if (!File.Exists(filename))
            {
                throw new ArgumentException($"Project does not exist: {filename}", nameof(filename));
            }

            var projectName = filename.Substring(filename.LastIndexOf("\\") + 1);

            var fileContents = File.ReadAllText(filename);
            var xel          = XElement.Parse(fileContents);

            // <Project>
            //   <ItemGroup>
            //     <PackageReference />
            //   </ItemGroup>
            // </Project>
            var referenceElements = xel.Elements()
                                    .Where(el => el.Name.LocalName == ITEM_GROUP)
                                    .SelectMany(g => g.Elements().Where(gel => gel.Name.LocalName == PACKAGE_REFERENCE));

            // <Project>
            //   <PropertyGroup>
            //     <TargetFramework />        ==> netstandard, netcoreapp
            //     <TargetFrameworkVersion /> ==> v4.5, v4.7.2, ...
            //   </PropertyGroup>
            // </Project>
            var frameworkEl = xel.Elements()
                              .Where(el => el.Name.LocalName == PROPERTY_GROUP)
                              .SelectMany(el => el.Elements().Where(pel => pel.Name.LocalName == TARGET_FRAMEWORK)
                                          .Concat(el.Elements().Where(cel => cel.Name.LocalName == TARGET_FRAMEWORK_VERSION)))
                              .FirstOrDefault();

            var frameworkName = frameworkEl?.Value;

            var dependencies = referenceElements.Select(element =>
            {
                // <PackageReference Include="Microsoft.Extensions.Logging.Abstractions">
                //     <Version>3.0.1</Version>
                // </PackageReference>
                // or:
                // <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="3.0.1" />
                var packageId = element.Attributes().FirstOrDefault(a => a.Name.LocalName == INCLUDE)?.Value;
                var versionId = element.Attributes().FirstOrDefault(a => a.Name.LocalName == VERSION)?.Value
                                ?? element.Elements().FirstOrDefault(el => el.Name.LocalName == VERSION)?.Value
                                ?? string.Empty;

                return(new Dependency
                {
                    Name = packageId,
                    Version = versionId,
                    Framework = frameworkName,
                    Project = projectName
                });
            });

            var project = new ProjectDependencyInfo()
            {
                FrameworkVersion = frameworkName ?? "Unknown",
                ProjectName      = projectName,
                Dependencies     = dependencies.ToList()
            };

            return(Task.FromResult(project));
        }