public static async Task <NuGetFramework> GetNuGetFrameworkAsync(
            IMSBuildProjectDataService dataService,
            string projectPath)
        {
            Assumes.Present(dataService);

            var targetPlatformIdentifier = await GetProjectPropertyAsync(dataService, TargetPlatformIdentifier);

            var targetPlatformVersion = await GetProjectPropertyAsync(dataService, TargetPlatformVersion);

            var targetPlatformMinVersion = await GetProjectPropertyAsync(dataService, TargetPlatformMinVersion);

            var targetFrameworkMoniker = await GetProjectPropertyAsync(dataService, TargetFrameworkMoniker);

            var frameworkStrings = MSBuildProjectFrameworkUtility.GetProjectFrameworkStrings(
                projectFilePath: projectPath,
                targetFrameworks: null,
                targetFramework: null,
                targetFrameworkMoniker: targetFrameworkMoniker,
                targetPlatformIdentifier: targetPlatformIdentifier,
                targetPlatformVersion: targetPlatformVersion,
                targetPlatformMinVersion: targetPlatformMinVersion);

            var frameworkString = frameworkStrings.FirstOrDefault();

            if (!string.IsNullOrEmpty(frameworkString))
            {
                return(NuGetFramework.Parse(frameworkString));
            }

            return(NuGetFramework.UnsupportedFramework);
        }
Exemplo n.º 2
0
        private static async Task <List <NuGetFramework> > GetNuGetFrameworks(
            IDeferredProjectWorkspaceService deferredWorkspaceService,
            IMSBuildProjectDataService dataService,
            string projectPath)
        {
            var targetFrameworks = await deferredWorkspaceService.GetProjectPropertyAsync(dataService, TargetFrameworks);

            if (!string.IsNullOrEmpty(targetFrameworks))
            {
                return(targetFrameworks
                       .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
                       .Select(NuGetFramework.Parse).ToList());
            }

            var targetFramework = await deferredWorkspaceService.GetProjectPropertyAsync(dataService, TargetFramework);

            if (!string.IsNullOrEmpty(targetFramework))
            {
                return(new List <NuGetFramework> {
                    NuGetFramework.Parse(targetFramework)
                });
            }

            // old packages.config style or legacy PackageRef
            return(new List <NuGetFramework> {
                await GetNuGetFramework(deferredWorkspaceService, dataService, projectPath)
            });
        }
Exemplo n.º 3
0
        public async Task <string> GetProjectPropertyAsync(IMSBuildProjectDataService dataService, string propertyName)
        {
            if (dataService == null)
            {
                throw new ArgumentNullException(nameof(dataService));
            }

            return((await dataService.GetProjectProperty(propertyName)).EvaluatedValue);
        }
Exemplo n.º 4
0
        private static async Task <List <string> > GetRuntimeSupports(
            IDeferredProjectWorkspaceService deferredWorkspaceService,
            IMSBuildProjectDataService dataService)
        {
            var supports = (await GetProjectPropertyOrDefault(deferredWorkspaceService, dataService, RuntimeSupports))
                           .Split(';')
                           .Where(s => !string.IsNullOrEmpty(s))
                           .ToList();

            return(supports);
        }
Exemplo n.º 5
0
        private static async Task <string> GetProjectPropertyOrDefault(
            IDeferredProjectWorkspaceService deferredWorkspaceService,
            IMSBuildProjectDataService dataService,
            string projectPropertyName,
            string defaultValue = "")
        {
            var propertyValue = await deferredWorkspaceService.GetProjectPropertyAsync(dataService, projectPropertyName);

            if (!string.IsNullOrEmpty(propertyValue))
            {
                return(propertyValue);
            }

            return(defaultValue);
        }
Exemplo n.º 6
0
        private static async Task <List <string> > GetRuntimeIdentifiers(
            IDeferredProjectWorkspaceService deferredWorkspaceService,
            IMSBuildProjectDataService dataService)
        {
            var runtimeIdentifier = await GetProjectPropertyOrDefault(deferredWorkspaceService, dataService, RuntimeIdentifier);

            var runtimeIdentifiers = await GetProjectPropertyOrDefault(deferredWorkspaceService, dataService, RuntimeIdentifiers);

            var runtimes = (new[] { runtimeIdentifier, runtimeIdentifiers })
                           .SelectMany(s => s.Split(';'))
                           .Where(s => !string.IsNullOrEmpty(s))
                           .ToList();

            return(runtimes);
        }
Exemplo n.º 7
0
        public async Task <IEnumerable <MSBuildProjectItemData> > GetProjectItemsAsync(IMSBuildProjectDataService dataService, string itemType)
        {
            if (dataService == null)
            {
                throw new ArgumentNullException(nameof(dataService));
            }

            return(await dataService.GetProjectItems(itemType));
        }
        public static async Task <string> GetProjectPropertyAsync(IMSBuildProjectDataService dataService, string propertyName)
        {
            Assumes.Present(dataService);

            return((await dataService.GetProjectProperty(propertyName)).EvaluatedValue);
        }