private static void Configure(EnvironmentOptions options) { var settingsRepository = new SettingsRepository(); EnvironmentName = options.Environment; Settings = settingsRepository.GetEnvironment(options); }
/// <summary> /// Builds the requested target framework(s). /// </summary> /// <param name="targetFrameworks">The set of target frameworks to build.</param> /// <param name="environmentOptions">The environment options to use for the build.</param> /// <returns>A dictionary of target frameworks to <see cref="AnalyzerResult"/>.</returns> public AnalyzerResults Build(string[] targetFrameworks, EnvironmentOptions environmentOptions) { if (environmentOptions == null) { throw new ArgumentNullException(nameof(environmentOptions)); } // If the set of target frameworks is empty, just build the default if (targetFrameworks == null || targetFrameworks.Length == 0) { targetFrameworks = new string[] { null }; } // Create a new build envionment for each target AnalyzerResults results = new AnalyzerResults(); foreach (string targetFramework in targetFrameworks) { BuildEnvironment buildEnvironment = EnvironmentFactory.GetBuildEnvironment(targetFramework, environmentOptions); string[] targetsToBuild = buildEnvironment.TargetsToBuild; Restore(buildEnvironment, ref targetsToBuild); results.Add(BuildTargets(buildEnvironment, targetFramework, targetsToBuild, true)); } return(results); }
public EnvironmentSettings GetEnvironment(EnvironmentOptions options) { var result = new EnvironmentSettings(); var settingsRepository = new SettingsRepository(); var _settings = settingsRepository.FindEnvironment(options.Environment); result.Uri = string.IsNullOrEmpty(options.Uri) ? _settings.Uri : options.Uri; result.IsNetCore = options.IsNetCore ?? _settings.IsNetCore; result.DeveloperModeEnabled = options.DeveloperModeEnabled ?? _settings.DeveloperModeEnabled; result.Login = string.IsNullOrEmpty(options.Login) ? _settings.Login : options.Login; result.Password = string.IsNullOrEmpty(options.Password) ? _settings.Password : options.Password; result.Maintainer = string.IsNullOrEmpty(options.Maintainer) ? _settings.Maintainer : options.Maintainer; if (_settings.Safe.HasValue && _settings.Safe.Value) { Console.WriteLine($"You try to apply the action on the production site {_settings.Uri}"); Console.Write($"Do you want to continue? [Y/N]:"); var answer = Console.ReadKey(); Console.WriteLine(); if (answer.KeyChar != 'y' && answer.KeyChar != 'Y') { Console.WriteLine("Operation was canceled by user"); System.Environment.Exit(1); } } return(result); }
public void GetsProjectGuidFromProject([ValueSource(nameof(Preferences))] EnvironmentPreference preference) { // Given const string projectFile = @"SdkNetCoreProject\SdkNetCoreProject.csproj"; IProjectAnalyzer analyzer = new AnalyzerManager() .GetProject(GetProjectPath(projectFile)); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When DeleteProjectDirectory(projectFile, "obj"); DeleteProjectDirectory(projectFile, "bin"); IAnalyzerResults results = analyzer.Build(options); // Then // The generated GUIDs are based on subpath, so they'll be different from Windows to Linux // They can also change between MSBuild versions, so this may need to be updated periodically #if Is_Windows results.First().ProjectGuid.ToString().ShouldBe("432bfde1-4768-5837-8e20-8bb49c9d4734"); #else results.First().ProjectGuid.ToString().ShouldBe("c9df4376-d954-5554-bd10-b9976b7afa9d"); #endif }
public void GetsSourceFiles( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); IProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When IAnalyzerResults results = analyzer.Build(options); // Then // If this is the multi-targeted project, use the net462 target IReadOnlyList <string> sourceFiles = results.Count == 1 ? results.First().SourceFiles : results["net462"].SourceFiles; sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
/// <summary> /// Builds the requested target framework(s). /// </summary> /// <param name="targetFrameworks">The set of target frameworks to build.</param> /// <param name="environmentOptions">The environment options to use for the build.</param> /// <returns>A dictionary of target frameworks to <see cref="AnalyzerResult"/>.</returns> public AnalyzerResults Build(string[] targetFrameworks, EnvironmentOptions environmentOptions) { if (environmentOptions == null) { throw new ArgumentNullException(nameof(environmentOptions)); } // If the set of target frameworks is empty, just build the default if (targetFrameworks == null || targetFrameworks.Length == 0) { targetFrameworks = new string[] { null }; } // Reset the cache before every build in case MSBuild cached something from a project reference build Manager.BuildManager.ResetCaches(); // Create a new build envionment for each target AnalyzerResults results = new AnalyzerResults(); foreach (string targetFramework in targetFrameworks) { BuildEnvironment buildEnvironment = EnvironmentFactory.GetBuildEnvironment(targetFramework, environmentOptions); string[] targetsToBuild = buildEnvironment.TargetsToBuild; Restore(buildEnvironment, ref targetsToBuild); results.Add(BuildTargets(buildEnvironment, targetFramework, targetsToBuild)); } return(results); }
public static AdhocWorkspace GetWorkspaceWithPreventBuildEvent(this AnalyzerManager manager) { // info article: https://qiita.com/skitoy4321/items/9edfb094549f5167a57f var projPath = manager.Projects.First().Value.ProjectFile.Path; var tempPath = Path.Combine(new FileInfo(projPath).Directory.FullName, "__buildtemp") + System.IO.Path.DirectorySeparatorChar; var envopts = new EnvironmentOptions(); // "Clean" and "Build" is listed in default // Modify to designtime system https://github.com/dotnet/project-system/blob/master/docs/design-time-builds.md#targets-that-run-during-design-time-builds // that prevent Pre/PostBuildEvent envopts.TargetsToBuild.Clear(); // Clean should not use(if use pre/post build, dll was deleted). // envopts.TargetsToBuild.Add("Clean"); envopts.TargetsToBuild.Add("ResolveAssemblyReferencesDesignTime"); envopts.TargetsToBuild.Add("ResolveProjectReferencesDesignTime"); envopts.TargetsToBuild.Add("ResolveComReferencesDesignTime"); envopts.TargetsToBuild.Add("Compile"); envopts.GlobalProperties["IntermediateOutputPath"] = tempPath; try { return(GetWorkspace(manager, envopts)); } finally { if (Directory.Exists(tempPath)) { Directory.Delete(tempPath, true); } } }
public MsBuildExeFixtureResult Execute() { var analyzer = manager.GetProject(ProjectPath); var output = new StringWriter(); analyzer.AddBuildLogger(new ConsoleLogger(LoggerVerbosity.Normal, output.Write, null, null)); var environmentOptions = new EnvironmentOptions { DesignTime = false }; environmentOptions.TargetsToBuild.Clear(); environmentOptions.TargetsToBuild.Add(OutputTarget); if (environmentVariables != null) { foreach (var pair in environmentVariables) { analyzer.SetEnvironmentVariable(pair.Key, pair.Value); } } var results = analyzer.Build(environmentOptions); return(new MsBuildExeFixtureResult(fixture) { ProjectPath = ProjectPath, Output = output.ToString(), MsBuild = results }); }
public VideoProfile(EnvironmentOptions env) { _env = env; CreateMap <Video, VideoDetail>() .ForMember(dest => dest.Tags, map => map.MapFrom(v => v.Tags.Select(t => t.Name).ToList())) .ForMember(dest => dest.ThumbURL, map => map.MapFrom(v => $"{_env.ApiUrl}/{v.ThumbURL}")); }
public Project Load(string targetFramework, EnvironmentOptions environmentOptions) { if (environmentOptions == null) { throw new ArgumentNullException(nameof(environmentOptions)); } return(Load(targetFramework, EnvironmentFactory.GetBuildEnvironment(targetFramework, environmentOptions))); }
public Project Load(EnvironmentOptions environmentOptions) { if (environmentOptions == null) { throw new ArgumentNullException(nameof(environmentOptions)); } return(Load(null, EnvironmentFactory.GetBuildEnvironment(environmentOptions))); }
/// <summary> /// Builds a specific target framework. /// </summary> /// <param name="targetFramework">The target framework to build.</param> /// <param name="environmentOptions">The environment options to use for the build.</param> /// <returns>The result of the build process.</returns> public AnalyzerResults Build(string targetFramework, EnvironmentOptions environmentOptions) { if (environmentOptions == null) { throw new ArgumentNullException(nameof(environmentOptions)); } return(Build(targetFramework, EnvironmentFactory.GetBuildEnvironment(targetFramework, environmentOptions))); }
private EnvironmentOptions GetEnvironmentOptions(bool requiresNetFramework, string toolsVersion) { var os = DetermineOSPlatform(); EnvironmentOptions options = new EnvironmentOptions(); if (os == OSPlatform.Linux || os == OSPlatform.OSX) { if (requiresNetFramework) { options.EnvironmentVariables.Add(EnvironmentVariables.MSBUILD_EXE_PATH, Constants.MsBuildCommandName); } } //We want to provide the MsBuild path only if it's a framework solution. Buildalyzer automatically builds core solutions using "dotnet" if (requiresNetFramework) { try { var msbuildExe = _analyzerConfiguration.BuildSettings.MSBuildPath; if (string.IsNullOrEmpty(msbuildExe)) { msbuildExe = _msBuildDetector.GetFirstMatchingMsBuildFromPath(toolsVersion: toolsVersion); } if (!string.IsNullOrEmpty(msbuildExe)) { options.EnvironmentVariables.Add(EnvironmentVariables.MSBUILD_EXE_PATH, msbuildExe); } else { throw new Exception(); } } catch (Exception ex) { Logger.LogError(ex, "Build error: Codelyzer wasn't able to retrieve the MSBuild path"); } _analyzerConfiguration.BuildSettings.BuildArguments.ForEach(argument => { options.Arguments.Add(argument); }); } options.EnvironmentVariables.Add(Constants.EnableNuGetPackageRestore, Boolean.TrueString.ToLower()); if (_analyzerConfiguration.MetaDataSettings.GenerateBinFiles) { options.GlobalProperties.Add(MsBuildProperties.CopyBuildOutputToOutputDirectory, "true"); options.GlobalProperties.Add(MsBuildProperties.CopyOutputSymbolsToOutputDirectory, "true"); options.GlobalProperties.Add(MsBuildProperties.UseCommonOutputDirectory, "false"); options.GlobalProperties.Add(MsBuildProperties.SkipCopyBuildProduct, "false"); options.GlobalProperties.Add(MsBuildProperties.SkipCompilerExecution, "false"); if (!requiresNetFramework) { options.GlobalProperties.Add(MsBuildProperties.BuildProjectReferences, "true"); } } return(options); }
public static string GetEnumDescription(this EnvironmentOptions value) { var description = value.GetType() .GetMember(value.ToString()) .FirstOrDefault() ?.GetCustomAttribute <DescriptionAttribute>() ?.Description; return(description); }
public void CompilesProject(EnvironmentPreference preference, string solutionPath, string projectPath) { // Given StringWriter log = new StringWriter(); AnalyzerManager manager = new AnalyzerManager(solutionPath, new AnalyzerManagerOptions { LogWriter = log }); ProjectAnalyzer analyzer = manager.GetProject(projectPath); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // Set some enviornment variables to make it seem like we're not in a CI build // Sometimes this messes up libraries like SourceLink since we're building as part of a test and not for CI options.EnvironmentVariables.Add("APPVEYOR", "False"); options.EnvironmentVariables.Add("ContinuousIntegrationBuild", null); options.EnvironmentVariables.Add("CI", "False"); options.EnvironmentVariables.Add("CI_LINUX", "False"); options.EnvironmentVariables.Add("CI_WINDOWS", "False"); // When DeleteProjectDirectory(analyzer.ProjectFile.Path, "obj"); DeleteProjectDirectory(analyzer.ProjectFile.Path, "bin"); analyzer.IgnoreFaultyImports = false; #pragma warning disable 0162 if (BinaryLog) { analyzer.AddBinaryLogger($@"E:\Temp\{Path.GetFileNameWithoutExtension(solutionPath)}.{Path.GetFileNameWithoutExtension(analyzer.ProjectFile.Path)}.core.binlog"); } #pragma warning restore 0162 #if Is_Windows AnalyzerResults results = analyzer.Build(options); #else // On non-Windows platforms we have to remove the .NET Framework target frameworks and only build .NET Core target frameworks // See https://github.com/dotnet/sdk/issues/826 string[] excludedTargetFrameworks = new[] { "net2", "net3", "net4", "portable" }; string[] targetFrameworks = analyzer.ProjectFile.TargetFrameworks.Where(x => !excludedTargetFrameworks.Any(y => x.StartsWith(y))).ToArray(); if (targetFrameworks.Length == 0) { Assert.Ignore(); } AnalyzerResults results = analyzer.Build(targetFrameworks, options); #endif // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.OverallSuccess.ShouldBeTrue(log.ToString()); results.ShouldAllBe(x => x.Succeeded, log.ToString()); }
public DefaultIssuerService( CertValidationOptions storeOptions, EnvironmentOptions environment, ILogger <DefaultIssuerService> logger ) { _options = storeOptions; _logger = logger; _path = environment.ContentRoot; Load(); }
public EnvironmentStatePollingSynchronizer( ILogger <EnvironmentStatePollingSynchronizer> logger, IEnvironmentStateProvider provider, IEnvironmentStateRepository repo, IOptions <EnvironmentStatePollingSynchronizerOptions> pollingOptions, IOptions <EnvironmentOptions> environmentOptions) { _logger = logger; _provider = provider; _repo = repo; _pollingOptions = pollingOptions.Value; _environmentOptions = environmentOptions.Value; }
public VideoService(IUnitOfWork unitOfWork, IdentityOptions identity, IFileStorageService storage, EnvironmentOptions env, IMapper mapper, ICommentService commentService) { _unitOfWork = unitOfWork; _identity = identity; _storage = storage; _env = env; _mapper = mapper; _commentService = commentService; }
public void GetsSourceFilesFromBinLogFile(string path, int expectedVersion) { // Verify this is the expected version path = Path.GetFullPath( Path.Combine( Path.GetDirectoryName(typeof(SimpleProjectsFixture).Assembly.Location), "..", "..", "..", "..", "binlogs", path)) .Replace('\\', Path.DirectorySeparatorChar); EnvironmentOptions options = new EnvironmentOptions(); using (Stream stream = File.OpenRead(path)) { using (GZipStream gzip = new GZipStream(stream, CompressionMode.Decompress)) { using (BinaryReader reader = new BinaryReader(gzip)) { reader.ReadInt32().ShouldBe(expectedVersion); } } } // Given StringWriter log = new StringWriter(); AnalyzerManager analyzerManager = new AnalyzerManager( new AnalyzerManagerOptions { LogWriter = log }); // When IAnalyzerResults analyzerResults = analyzerManager.Analyze(path); IReadOnlyList <string> sourceFiles = analyzerResults.First().SourceFiles; // Then sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
public void GetsSourceFilesFromVersion9BinLog() { // Given StringWriter log = new StringWriter(); IProjectAnalyzer analyzer = GetProjectAnalyzer( @"SdkNetCore31Project\SdkNetCore31Project.csproj", log); string binLogPath = Path.ChangeExtension(Path.GetTempFileName(), ".binlog"); EnvironmentOptions options = new EnvironmentOptions(); options.Arguments.Add("/bl:" + binLogPath); // Tell MSBuild to produce the binlog so we use the latest internal logger try { // When analyzer.Build(options); using (Stream stream = File.OpenRead(binLogPath)) { using (GZipStream gzip = new GZipStream(stream, CompressionMode.Decompress)) { using (BinaryReader reader = new BinaryReader(gzip)) { // Verify this produced a version 9 binlog reader.ReadInt32().ShouldBe(9); } } } IReadOnlyList <string> sourceFiles = analyzer.Manager.Analyze(binLogPath).First().SourceFiles; // Then sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); } finally { if (File.Exists(binLogPath)) { File.Delete(binLogPath); } } }
private HttpClient CreateUpmClient(IConfiguration configuration) { var envOptions = new EnvironmentOptions(); configuration.GetSection("dimensionData:environment").Bind(envOptions); IServiceDiscoveryClient serviceDiscoveryClient = new ServiceDiscoveryClient(Options.Create(envOptions)); string upmKey = Configuration["dimensionData:ui:keys:upm"]; var baseAddress = serviceDiscoveryClient.FindGlobalApiService(upmKey).Result; return(new HttpClientBuilder() .SetBaseAddress(baseAddress) .SetRetryPolicy(3, TimeSpan.FromSeconds(1), 2) .Build()); }
/// <summary> /// Builds all target framework(s) with the specified build environment options. /// </summary> /// <param name="environmentOptions">The environment options to use for the build.</param> /// <returns>A dictionary of target frameworks to <see cref="AnalyzerResult"/>.</returns> public AnalyzerResults BuildAllTargetFrameworks(EnvironmentOptions environmentOptions) { if (environmentOptions == null) { throw new ArgumentNullException(nameof(environmentOptions)); } // Load the project with the default build environment to get the evaluated target frameworks Project project = Load(EnvironmentFactory.GetBuildEnvironment(environmentOptions)); // Get all evaluated target frameworks from the Project and build them // but don't worry about getting a single target framework, it'll build the default string[] targetFrameworks = ProjectFile.GetTargetFrameworks( new[] { project.GetPropertyValue(ProjectFileNames.TargetFrameworks) }, null, null); return(Build(targetFrameworks, environmentOptions)); }
public static AdhocWorkspace GetWorkspace(this AnalyzerManager manager, EnvironmentOptions envOptions) { // Run builds in parallel List <AnalyzerResult> results = manager.Projects.Values .AsParallel() .Select(p => p.Build(envOptions).FirstOrDefault()) // with envoption .Where(x => x != null) .ToList(); // Add each result to a new workspace AdhocWorkspace workspace = new AdhocWorkspace(); foreach (AnalyzerResult result in results) { result.AddToWorkspace(workspace); } return(workspace); }
public NeuroGeneticAlgorithm(IFittnessFunction <Neuron> fittnessFunction, ISelection <Neuron> selection, ICrossover <Neuron> crossover, IMutation <Neuron> mutation, ITerminate <Neuron> terminate, NeuralNetwork networkForTeach) : base(fittnessFunction, selection, crossover, mutation, terminate) { NeuralNetwork = networkForTeach; Random = new Random((int)DateTime.Now.Ticks); generateNeuroPopulation_(); var options = new EnvironmentOptions { AgentsCount = Population.Count, FoodCount = 5, FieldWidth = 200, FieldHeight = 200 }; TestGameEnvironment = new GameEnvironment(options); }
private EnvironmentOptions GetEnvironmentOptions(IProjectFile projectFile) { var os = DetermineOSPlatform(); EnvironmentOptions options = new EnvironmentOptions(); if (os == OSPlatform.Linux || os == OSPlatform.OSX) { var requiresNetFramework = false; /* * We need to have this property in a try/catch because there are cases when there are additional Import or LanguageTarget tags * with unexpected (or missing) attributes. This avoids a NPE in buildalyzer code retrieving this property */ try { requiresNetFramework = projectFile.RequiresNetFramework; } catch (Exception ex) { Logger.LogError(ex, "Error while checking if project is a framework project"); } if (requiresNetFramework) { options.EnvironmentVariables.Add(EnvironmentVariables.MSBUILD_EXE_PATH, Constants.MsBuildCommandName); } } options.EnvironmentVariables.Add(Constants.EnableNuGetPackageRestore, Boolean.TrueString.ToLower()); options.Arguments.Add(Constants.RestorePackagesConfigArgument); options.Arguments.Add(Constants.LanguageVersionArgument); if (_analyzerConfiguration.MetaDataSettings.GenerateBinFiles) { options.GlobalProperties.Add(MsBuildProperties.CopyBuildOutputToOutputDirectory, "true"); options.GlobalProperties.Add(MsBuildProperties.CopyOutputSymbolsToOutputDirectory, "true"); options.GlobalProperties.Add(MsBuildProperties.UseCommonOutputDirectory, "false"); options.GlobalProperties.Add(MsBuildProperties.SkipCopyBuildProduct, "false"); options.GlobalProperties.Add(MsBuildProperties.SkipCompilerExecution, "false"); } return(options); }
public void BuildsProject(string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { DesignTime = false }; // When DeleteProjectDirectory(projectFile, "obj"); DeleteProjectDirectory(projectFile, "bin"); AnalyzerResults results = analyzer.BuildAllTargetFrameworks(options); // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.First().ProjectInstance.ShouldNotBeNull(log.ToString()); }
public void GetsSourceFilesFromBinaryLog( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); IProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; string binLogPath = Path.ChangeExtension(Path.GetTempFileName(), ".binlog"); analyzer.AddBinaryLogger(binLogPath); try { // When analyzer.Build(options); IAnalyzerResults results = analyzer.Manager.Analyze(binLogPath); // Then // If this is the multi-targeted project, use the net462 target IReadOnlyList <string> sourceFiles = results.Count == 1 ? results.First().SourceFiles : results["net462"].SourceFiles; sourceFiles.ShouldNotBeNull(log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); } finally { if (File.Exists(binLogPath)) { File.Delete(binLogPath); } } }
public void GetsProjectGuidFromSolution([ValueSource(nameof(Preferences))] EnvironmentPreference preference) { // Given AnalyzerManager manager = new AnalyzerManager( GetProjectPath("TestProjects.sln")); IProjectAnalyzer analyzer = manager.Projects.First(x => x.Key.EndsWith("SdkNetStandardProject.csproj")).Value; EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When DeleteProjectDirectory(analyzer.ProjectFile.Path, "obj"); DeleteProjectDirectory(analyzer.ProjectFile.Path, "bin"); IAnalyzerResults results = analyzer.Build(options); // Then results.First().ProjectGuid.ToString().ShouldBe("016713d9-b665-4272-9980-148801a9b88f"); }
public IEnumerable <string> EnumerateProjectFilesRelative(string projectPath) { // Use an environment variable to try to prevent recursively calling this // build target when we call .Build below const string EnvVar = "_DRWLA_ARM_BUILD"; if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(EnvVar))) { yield break; } var manager = new AnalyzerManager(); var analyzer = manager.GetProject(projectPath); var environmentOptions = new EnvironmentOptions { // MUST USE DESIGN TIME BUILD // In the .targets definition we have a condition // to avoid running the DurwellaAzureArmTestingTarget at Design Time // https://github.com/dotnet/project-system/blob/master/docs/design-time-builds.md DesignTime = true, EnvironmentVariables = { { EnvVar, "RUNNING" } } }; var results = analyzer.Build(environmentOptions); // Returns one result per framework target var result = results.First(); var items = result.Items; foreach (var item in items) { // Skip keys like ProjectReference that aren't for files if (!InlcudedProjectKeys.Contains(item.Key)) { continue; } var projectItems = item.Value; foreach (var projectItem in projectItems) { // The item spec for files will be the path relative to the project directory yield return(projectItem.ItemSpec); } } }
public void DesignTimeBuildsProject( [ValueSource(nameof(Preferences))] EnvironmentPreference preference, [ValueSource(nameof(ProjectFiles))] string projectFile) { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log); EnvironmentOptions options = new EnvironmentOptions { Preference = preference }; // When DeleteProjectDirectory(projectFile, "obj"); DeleteProjectDirectory(projectFile, "bin"); AnalyzerResults results = analyzer.Build(options); // Then results.Count.ShouldBeGreaterThan(0, log.ToString()); results.ShouldAllBe(x => x.OverallSuccess, log.ToString()); }