public static TaskRunnerResult Execute(string assemblyPath, string projectPath) { var assembly = Assembly.LoadFrom(assemblyPath); Dictionary <Type, IPostCompileTask> tasks = (from type in assembly.GetTypes() where typeof(IPostCompileTask).IsAssignableFrom(type) where !type.IsAbstract where type.HasDefaultConstructor() select type).ToDictionary(x => x, x => (IPostCompileTask)Activator.CreateInstance(x)); CheckTaskDependencies(tasks); List <IPostCompileTask> sortedTaskInstances = tasks.Values.TopologicalSort(x => x.DependsOn.Select(y => tasks[y])).ToList(); AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(projectPath); AdhocWorkspace workspace = analyzer.GetWorkspace(); Solution solution = workspace.CurrentSolution; var log = new ConcreteLog(solution, Console.Out); foreach (var taskInstance in sortedTaskInstances) { taskInstance.Log = log; taskInstance.RunAsync().Wait(); } // Return task types that need to be removed return(new TaskRunnerResult { TaskTypes = tasks.Select(x => x.Key.FullName).ToList() }); }
private static void RunDotNetCommand(string text, StringBuilder outputBuffer, StringBuilder errorBuffer) { if (!text.StartsWith("dotnet ")) { throw new ArgumentException("Unexpected dotnet command: " + text, nameof(text)); } using (Process dotnet = new Process()) { dotnet.StartInfo.FileName = "dotnet"; dotnet.StartInfo.Arguments = text.Substring("dotnet ".Length); dotnet.StartInfo.UseShellExecute = false; dotnet.StartInfo.CreateNoWindow = true; dotnet.StartInfo.RedirectStandardOutput = true; dotnet.StartInfo.RedirectStandardError = true; dotnet.OutputDataReceived += (sender, args) => outputBuffer.AppendLine(args.Data); dotnet.ErrorDataReceived += (sender, args) => errorBuffer.AppendLine(args.Data); dotnet.Start(); dotnet.BeginOutputReadLine(); dotnet.BeginErrorReadLine(); dotnet.WaitForExit(); dotnet.CancelOutputRead(); dotnet.CancelErrorRead(); } AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(@"C:\Users\wafuqua\.replay\ReplaySession20190302153809\Session\Session.csproj"); var result = analyzer.Build(); ; }
private static async Task RunFormatItemAsync(IFormattingEngine engine, string item, string language, CancellationToken cancellationToken) { Console.WriteLine(Path.GetFileName(item)); string extension = Path.GetExtension(item); if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".rsp")) { using (var workspace = ResponseFileWorkspace.Create()) { Project project = workspace.OpenCommandLineProject(item, language); await engine.FormatProjectAsync(project, cancellationToken); } } else if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln")) { AnalyzerManager manager = new AnalyzerManager(item); using (var workspace = manager.GetWorkspace()) { var solution = workspace.CurrentSolution; await engine.FormatSolutionAsync(solution, cancellationToken); } } else { AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(item); using (var workspace = analyzer.GetWorkspace()) { var project = workspace.CurrentSolution.Projects.FirstOrDefault(); await engine.FormatProjectAsync(project, cancellationToken); } } }
private IEnumerable <PackageReferenceInfo> LoadPackageReferences(ProjectAnalyzer projectAnalyzer) { AnalyzerResults project = projectAnalyzer.Build(); var packageReferenceInfo = new List <PackageReferenceInfo>(); var packagesRootFolder = GetPackagesRootFolder(); foreach (var result in project.Results) { packageReferenceInfo.AddRange(result.PackageReferences.Select(packageReference => { var packageId = packageReference.Key; var version = packageReference.Value.First().Value; var packageFolderPath = Path.Combine(packagesRootFolder, packageId.ToLower(), version.ToLower()); return(new PackageReferenceInfo( packageId, version, rootFolderPath: packageFolderPath, libSubfolderPath: "lib")); })); } return(packageReferenceInfo); }
static void Main(string project, string[] transformers) { AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(project); AdhocWorkspace workspace = new AdhocWorkspace(); analyzer.SetGlobalProperty("BuildingFromCodeGeneration", "true"); var Project = analyzer.AddToWorkspace(workspace, true); if (Project is null) { throw new ArgumentException($"Project is null. ({project})"); } var resolver = new CSharpAutofacResolver(); var Engine = new CSharpCodeGenerationEngine(Project, resolver); foreach (var item in transformers) { var assembly = LoadAssembly(item); var transformer = LoadTransformer(assembly, Engine); transformer.Transform(); } var changes = Engine.CurrentProject.GetChanges(Project); Procces(Engine, project, changes.GetAddedDocuments(), "Added"); var changedDocs = changes.GetChangedDocuments(false).Where(x => Engine.CurrentProject.GetDocument(x).GetTextChangesAsync(Project.GetDocument(x)).Result.Any()); Procces(Engine, project, changedDocs, "Updated"); }
public void MultiTargetingBuildAllTargetFrameworksGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When AnalyzerResults results = analyzer.Build(); // Then results.Count.ShouldBe(2); results.TargetFrameworks.ShouldBe(new[] { "net462", "netstandard2.0" }, true, log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class1", "AssemblyInfo" }.ShouldBeSubsetOf(results["net462"].SourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); new[] { #if Is_Windows // Linux and Mac builds appear to omit the AssemblyAttributes.cs file "AssemblyAttributes", #endif "Class2", "AssemblyInfo" }.ShouldBeSubsetOf(results["netstandard2.0"].SourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString()); }
public AnalyzeCommand(IConsole console) { _console = console; _builder = new ProjectBuilder(console); _analyzer = new ProjectAnalyzer(); _reporter = new ProjectReporter(console); }
public static string GetTargetFramework(string projectFile) { AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(projectFile); return(analyzer.Project.GetPropertyValue("TargetFramework")); }
public static FileInfo[] GetSourcesFromSolution(FileInfo solution) { List <FileInfo> ret = new List <FileInfo>(); //We are using Buildalyzer because it is xplat AnalyzerManager manager = new AnalyzerManager(solution.FullName); foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects) { ProjectAnalyzer analyzer = proj.Value; analyzer.IgnoreFaultyImports = true; if (analyzer.ProjectFile.RequiresNetFramework) { throw new Exception( ".NET Framework Solutions not supported. Please use a .NET Core Solution instead."); } AnalyzerResults results = analyzer.Build(); foreach (string filePath in results.SelectMany(s => s.SourceFiles)) { if (!File.Exists(filePath)) { Log.Warn("Source file {0} is missing."); } ret.Add(new FileInfo(filePath)); } } return(ret.ToArray()); }
private Compilation AddProjectReferences(IExecutionContext context, List <ISymbol> symbols, Compilation compilation) { // Generate a single Workspace and add all of the projects to it StringWriter log = new StringWriter(); AnalyzerManager manager = new AnalyzerManager(log); AdhocWorkspace workspace = new AdhocWorkspace(); IEnumerable <IFile> projectFiles = context.FileSystem.GetInputFiles(_projectGlobs) .Where(x => x.Path.Extension == ".csproj" && x.Exists); List <Project> projects = new List <Project>(); foreach (IFile projectFile in projectFiles) { Project project = workspace.CurrentSolution.Projects.FirstOrDefault(x => new FilePath(x.FilePath).Equals(projectFile.Path)); if (project != null) { Trace.Verbose($"Project {projectFile.Path.FullPath} was already in the workspace"); } else { Trace.Verbose($"Creating workspace project for {projectFile.Path.FullPath}"); ProjectAnalyzer analyzer = manager.GetProject(projectFile.Path.FullPath); ReadWorkspace.CompileProjectAndTrace(analyzer, log); project = analyzer.AddToWorkspace(workspace); if (!project.Documents.Any()) { Trace.Warning($"Project at {projectFile.Path.FullPath} contains no documents, which may be an error (check previous log output for any MSBuild warnings)"); } } projects.Add(project); } compilation = AddProjectReferences(projects, symbols, compilation); return(compilation); }
public static MetadataReference[] GetMetadataReferencesFromSolution(FileInfo solution) { List <MetadataReference> ret = new List <MetadataReference>(); //We are using Buildalyzer because it is xplat AnalyzerManager manager = new AnalyzerManager(solution.FullName); foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects) { ProjectAnalyzer analyzer = proj.Value; analyzer.IgnoreFaultyImports = true; if (analyzer.ProjectFile.RequiresNetFramework) { throw new Exception( ".NET Framework Solutions not supported. Please use a .NET Core Solution instead."); } AnalyzerResults results = analyzer.Build(); foreach (string filePath in results.SelectMany(s => s.References))//TODO - are these all references? Research needed { if (!File.Exists(filePath)) { Log.Warn("Library {0} is missing. Did you restore the Solution libraries?"); } ret.Add(MetadataReference.CreateFromFile(filePath)); } } return(ret.ToArray()); }
public EventProcessor(AnalyzerManager manager, ProjectAnalyzer analyzer, IEnumerable <Microsoft.Build.Framework.ILogger> buildLoggers, IEventSource eventSource, bool analyze) { _manager = manager; _analyzer = analyzer; _logger = manager.LoggerFactory?.CreateLogger <EventProcessor>(); _buildLoggers = buildLoggers ?? Array.Empty <Microsoft.Build.Framework.ILogger>(); _eventSource = eventSource; _analyze = analyze; _projectFilePath = _analyzer?.ProjectFile.Path; // Initialize the loggers foreach (Microsoft.Build.Framework.ILogger buildLogger in _buildLoggers) { buildLogger.Initialize(eventSource); } // Send events to the tree constructor if (analyze) { eventSource.ProjectStarted += ProjectStarted; eventSource.ProjectFinished += ProjectFinished; eventSource.TargetStarted += TargetStarted; eventSource.TargetFinished += TargetFinished; eventSource.MessageRaised += MessageRaised; eventSource.BuildFinished += BuildFinished; if (_logger != null) { eventSource.ErrorRaised += ErrorRaised; } } }
public IEnumerable <FileInfo> GetSources(FileInfo solution) { List <FileInfo> ret = new List <FileInfo>(); AnalyzerManager manager = new AnalyzerManager(solution.FullName); foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects) { ProjectAnalyzer analyzer = proj.Value; analyzer.IgnoreFaultyImports = true; if (analyzer.ProjectFile.RequiresNetFramework) { throw new Exception( ".NET Framework Solutions not supported. Please use a .NET Core Solution instead."); } AnalyzerResults results = analyzer.Build(); foreach (string filePath in results.SelectMany(s => s.SourceFiles)) { if (!File.Exists(filePath)) { throw new Exception($"Source file {filePath} is missing!"); } ret.Add(new FileInfo(filePath)); } } return(ret); }
public void BuildTargetFrameworkGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When IReadOnlyList <string> sourceFiles = analyzer.Build("net462").GetSourceFiles(); // Then sourceFiles.ShouldNotBeNull(log.ToString()); sourceFiles.Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class1", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); // When log.GetStringBuilder().Clear(); sourceFiles = analyzer.Build("netstandard2.0").GetSourceFiles(); // Then sourceFiles.ShouldNotBeNull(log.ToString()); sourceFiles.Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class2", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); }
private async Task PendOrSubmitRequests(ProjectAnalyzer analyzer, string path) { List <string> pendingRequests; int originalCount; lock (_containersLock) { pendingRequests = _pendingRequests; _pendingRequests.Add(path); originalCount = _pendingRequests.Count; if (originalCount > 50) { _pendingRequests = new List <string>(); } } await Task.Delay(100).ConfigureAwait(false); lock (_containersLock) { if (pendingRequests.Count != originalCount) { return; } if (_pendingRequests == pendingRequests) { _pendingRequests = new List <string>(); } } await UpdateTestCasesAsync(analyzer, pendingRequests, true).ConfigureAwait(false); }
public void MultiTargetingBuildAllTargetFrameworksGetsSourceFiles() { // Given StringWriter log = new StringWriter(); ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log); // When AnalyzerResults results = analyzer.Build(); // Then results.Count.ShouldBe(2); results.TargetFrameworks.ShouldBe(new[] { "net462", "netstandard2.0" }, true, log.ToString()); results["net462"].GetSourceFiles().Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class1", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); results["netstandard2.0"].GetSourceFiles().Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[] { "Class2", "AssemblyAttributes", "AssemblyInfo" }, true, log.ToString()); }
public void GetsSourceFiles( [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 IReadOnlyList <string> sourceFiles = analyzer.Build(options).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()); }
private static Task <IProjectAnalyzationResult> AnalyzeProject(ProjectData projectData, ILoggerFactory loggerFactory, CancellationToken cancellationToken = default(CancellationToken)) { var analyzer = new ProjectAnalyzer(projectData, loggerFactory); return(analyzer.Analyze(cancellationToken)); }
internal MemberResult[] GetMemberNames(ProjectAnalyzer analyzer, string text) { _completionResultEvent.Reset(); _memberResults = null; using (new SocketLock(this)) { Socket.Send(GetMembersCommandBytes); SendString(text); } if (_completionResultEvent.WaitOne(1000) && _memberResults != null) { MemberResult[] res = new MemberResult[_memberResults.TypeMembers.Count + _memberResults.InstanceMembers.Count]; int i = 0; foreach (var member in _memberResults.TypeMembers) { res[i++] = CreateMemberResult(analyzer, member.Key, member.Value); } foreach (var member in _memberResults.InstanceMembers) { res[i++] = CreateMemberResult(analyzer, member.Key, member.Value); } _memberResults = null; return(res); } return(null); }
public AnalyzeCommand(IAnsiConsole console) { _console = console ?? throw new ArgumentNullException(nameof(console)); _builder = new ProjectBuilder(console); _analyzer = new ProjectAnalyzer(); _reporter = new ProjectReporter(console); }
public static Project CreateProject(UInt32 tag, PathDescriptor location, List <FileSystemDescriptor> files) { Project project = new Project(tag, location); files.ParallelFor((file) => { SharpReferenceNode node = new SharpReferenceNode(file as FileDescriptor); node.FetchExports(); lock (project) { project.Files.Nodes.Add(node); foreach (KeyValuePair <int, string> type in node.Declarations) { project.Files[type.Value].Add(node); } } if (node.Flags.Count != 0) { lock (project) project.AssemblyType = (OutputAssemblyType)node.Flags[0]; } }); ProjectAnalyzer.AddProjectFiles(project); return(project); }
public void Exec(string projectFilePath) { //string projectFilePath = @"C:\Users\USER\source\repos\ClassLibrary1\ClassLibrary1\ClassLibrary1.csproj"; string projectDirectory = Path.GetDirectoryName(projectFilePath); var manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(projectFilePath); using (var workspace = new AdhocWorkspace()) { Project roslynProject = analyzer.AddToWorkspace(workspace); if (roslynProject.Language != LanguageNames.CSharp) { throw new NotSupportedException($"The language: {roslynProject.Language} is not supported."); } var sourceCode = "namespace Foo{public class Foo{ }}"; Compilation compilation = roslynProject.GetCompilationAsync().Result; SyntaxTree stree = CSharpSyntaxTree.ParseText(sourceCode); SyntaxNode root = stree.GetCompilationUnitRoot(); UsingDirectiveSyntax[] usings = (root as CompilationUnitSyntax).Usings.ToArray(); NamespaceDeclarationSyntax namespaceNode = root.DescendantNodes().OfType <NamespaceDeclarationSyntax>().FirstOrDefault(); root = namespaceNode.WithName(SyntaxFactory.ParseName(compilation.GetEntryPoint(System.Threading.CancellationToken.None).ContainingNamespace.ToString())); root = (root as NamespaceDeclarationSyntax).AddUsings(usings); string fileName = GetFileName(root); fileName = Path.ChangeExtension(fileName, "cs"); string filePath = Path.Combine(projectDirectory, fileName); File.WriteAllText(filePath, root.ToFullString()); var documentId = DocumentId.CreateNewId(roslynProject.Id); var docInfo = DocumentInfo.Create(documentId, fileName, filePath: filePath); //await _addDocumentToProjectService.AddDocumentToProject(docInfo, projectFilePath).ConfigureAwait(false); } }
public async Task ProjectAnalyzer_ReadProjectFile() { var analyzer = new ProjectAnalyzer(new FileUtilities()); var projectReferenceList = await analyzer.AnalyzeProject(@"C:\VS2015\pp-git\LocationService\U4PP.Service.Location.API\U4PP.Service.Location.API.csproj"); ; }
public SyntaxNode Format(SyntaxNode tree) { AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(projectFile); var workspace = analyzer.GetWorkspace(); return(Formatter.Format(tree, workspace)); }
public void ThrowsForLegacyFrameworkProjectWithPackageReference() { // Given, When, Then AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(GetProjectPath(@"LegacyFrameworkProjectWithPackageReference\LegacyFrameworkProjectWithPackageReference.csproj")); Should.Throw <Exception>(() => analyzer.Load()); }
internal ProjectAnalyzer GetAnalyzer() { if (_analyzer == null) { _analyzer = CreateAnalyzer(); } return(_analyzer); }
/// <summary> /// Adds a project to an existing Roslyn workspace. /// </summary> /// <param name="analyzer">The Buildalyzer project analyzer.</param> /// <param name="workspace">A Roslyn workspace.</param> /// <param name="addProjectReferences"><c>true</c> to add projects to the workspace for project references that exist in the same <see cref="AnalyzerManager"/>.</param> /// <returns>The newly added Roslyn project.</returns> public static Project AddToWorkspace(this ProjectAnalyzer analyzer, Workspace workspace, bool addProjectReferences = false) { if (analyzer == null) { throw new ArgumentNullException(nameof(analyzer)); } if (workspace == null) { throw new ArgumentNullException(nameof(workspace)); } // Get or create an ID for this project string projectGuid = analyzer.CompiledProject?.GetPropertyValue("ProjectGuid"); ProjectId projectId = !string.IsNullOrEmpty(projectGuid) && Guid.TryParse(analyzer.CompiledProject?.GetPropertyValue("ProjectGuid"), out var projectIdGuid) ? ProjectId.CreateFromSerialized(projectIdGuid) : ProjectId.CreateNewId(); // Create and add the project ProjectInfo projectInfo = GetProjectInfo(analyzer, workspace, projectId); Solution solution = workspace.CurrentSolution.AddProject(projectInfo); // Check if this project is referenced by any other projects in the workspace foreach (Project existingProject in solution.Projects.ToArray()) { if (!existingProject.Id.Equals(projectId) && analyzer.Manager.Projects.TryGetValue(existingProject.FilePath, out ProjectAnalyzer existingAnalyzer) && (existingAnalyzer.GetProjectReferences()?.Contains(analyzer.ProjectFilePath) ?? false)) { // Add the reference to the existing project ProjectReference projectReference = new ProjectReference(projectId); solution = solution.AddProjectReference(existingProject.Id, projectReference); } } // Apply solution changes if (!workspace.TryApplyChanges(solution)) { throw new InvalidOperationException("Could not apply workspace solution changes"); } // Add any project references not already added if (addProjectReferences) { foreach (ProjectAnalyzer referencedAnalyzer in GetReferencedAnalyzerProjects(analyzer)) { // Check if the workspace contains the project inside the loop since adding one might also add this one due to transitive references if (!workspace.CurrentSolution.Projects.Any(x => x.FilePath == referencedAnalyzer.ProjectFilePath)) { AddToWorkspace(referencedAnalyzer, workspace, addProjectReferences); } } } // Find and return this project return(workspace.CurrentSolution.GetProject(projectId)); }
protected internal static void CompileProjectAndTrace(ProjectAnalyzer analyzer, StringWriter log) { log.GetStringBuilder().Clear(); if (analyzer.Compile() == null) { Trace.Error($"Could not compile project at {analyzer.ProjectFilePath}"); Trace.Warning(log.ToString()); } }
public static Task <CodeGenerator> CreateAsync(string projectFilePath) { AnalyzerManager manager = new AnalyzerManager(); ProjectAnalyzer analyzer = manager.GetProject(projectFilePath); AdhocWorkspace workspace = new AdhocWorkspace(); Project project = analyzer.AddToWorkspace(workspace); return(Task.FromResult(new CodeGenerator(project))); }
public void OneTimeSetup() { var workingDirectory = Environment.CurrentDirectory; _testProjectPath = Directory.GetParent(workingDirectory).Parent.Parent.FullName; var codeAnalyzer = CreateDefaultCodeAnalyzer(); // Get analyzer results from codelyzer (syntax trees, semantic models, package references, project references, etc) var analyzerResult = codeAnalyzer.AnalyzeProject(DownloadTestProjectsFixture.EShopLegacyWebFormsProjectPath).Result; var ctaArgs = new[] { "-p", DownloadTestProjectsFixture.EShopLegacyWebFormsProjectPath, // can hardcode for local use "-v", "net5.0", // set the Target Framework version "-d", "true", // use the default rules files (these will get downloaded from S3 and will tell CTA which packages to add to the new .csproj file) "-m", "false", // this is the "mock run" flag. Setting it to false means rules will be applied if we do a full port. }; // Handle argument assignment PortCoreRulesCli cli = new PortCoreRulesCli(); cli.HandleCommand(ctaArgs); if (cli.DefaultRules) { // Since we're using default rules, we want to specify where to find those rules (once they are downloaded) cli.RulesDir = Constants.RulesDefaultPath; } var packageReferences = new Dictionary <string, Tuple <string, string> > { { "Autofac", new Tuple <string, string>("4.9.1.0", "4.9.3") }, { "EntityFramework", new Tuple <string, string>("6.0.0.0", "6.4.4") }, { "log4net", new Tuple <string, string>("2.0.8.0", "2.0.12") }, { "Microsoft.Extensions.Logging.Log4Net.AspNetCore", new Tuple <string, string>("1.0.0", "2.2.12") } }; // Create a configuration object using the CLI and other arbitrary values PortCoreConfiguration projectConfiguration = new PortCoreConfiguration() { ProjectPath = cli.FilePath, RulesDir = cli.RulesDir, IsMockRun = cli.IsMockRun, UseDefaultRules = cli.DefaultRules, PackageReferences = packageReferences, PortCode = false, PortProject = true, TargetVersions = new List <string> { cli.Version } }; var projectRewriter = new ProjectRewriter(analyzerResult, projectConfiguration); ProjectResult projectResult = projectRewriter.Initialize(); _webFormsProjectAnalyzer = new ProjectAnalyzer(_testProjectPath, analyzerResult, projectConfiguration, projectResult); _blazorWorkspaceManager = new WorkspaceManagerService(); }