private static void Main()
{
// Рабочее пространство Roslyn
var workspace = MSBuildWorkspace.Create();
// Откроем решение, которое хотим анализировать
var solutionToAnalyze = workspace.OpenSolutionAsync(PathToSolution).Result;
// Получим проект, который хотим анализировать
var projectToAnalyze = solutionToAnalyze.Projects.FirstOrDefault(project => project.Name == ProjectName);
// Получим объект компиляции проекта
Debug.Assert(projectToAnalyze != null, "projectToAnalyze != null");
var compilationToAnalyze = projectToAnalyze.GetCompilationAsync().Result;
//var typeNames = compilationToAnalyze.Assembly.TypeNames;
//var classToAnalyze = typeNames.Where(typeName => typeName == ClassName);
var classToAnalyze = compilationToAnalyze.GetTypeByMetadataName(ClassName);
Debug.Assert(classToAnalyze != null);
var fullNamespace = classToAnalyze.GetFullNamespace();
WriteLine("Full namespace: {0}", fullNamespace);
var propertySymbol = classToAnalyze.GetMembers("MySimpleProperty").FirstOrDefault() as IPropertySymbol;
WriteLine("Fetched property: {0}", propertySymbol?.Name ?? "None");
var eventSymbol = classToAnalyze.GetMembers("MySimpleEvent").FirstOrDefault() as IEventSymbol;
WriteLine("Event name: {0}", eventSymbol?.Name ?? "None");
var methodSymbol = classToAnalyze.GetMembers("MySimpleMethod").FirstOrDefault() as IMethodSymbol;
var methodSignature = methodSymbol.GetMethodSignature();
WriteLine(methodSignature);
var attrData = classToAnalyze.GetAttributes().FirstOrDefault();
var intProperty = attrData.GetAttributeConstructorValueByParameterName("intProp");
WriteLine("Attribute's intProp = {0}", intProperty);
var stringProperty = attrData.GetAttributeConstructorValueByParameterName("stringProp");
WriteLine("Attrubute's string property = {0}", stringProperty);
}
static public void Analisys(string analisysProjectPath, string outGraphPath)
{
AnalisysCode analisys = new AnalisysCode("FieldBase");
//путь к анализируемому csproj файлу
string projectPath = analisysProjectPath;
//по указанному пути получаем проджект
MSBuildWorkspace msWorkspace = MSBuildWorkspace.Create();
var Project = msWorkspace.OpenProjectAsync(projectPath).Result;
analisys.ProjectAnalysis(Project);
var diagnostics = msWorkspace.Diagnostics;
foreach (var diagnostic in diagnostics)
{
Console.WriteLine(diagnostic.Message);
}
var entityInfos = analisys.entityInfos;
T4Generator t = new T4Generator(entityInfos);
String tText = t.TransformText();
Console.WriteLine(tText);
System.IO.File.WriteAllText(outGraphPath, tText);
foreach (var a in analisys.entityInfos)
{
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(a.className);
Console.WriteLine(a.baseClassName);
foreach (var b in a.lFieldInfo.Keys)
{
Console.WriteLine(b + " " + a.lFieldInfo[b].TypeField);
foreach (var c in a.lFieldInfo[b].lParamInfo)
{
Console.WriteLine(c.FieldName + " " + c.FieldType + " " + c.ParamName);
}
Console.WriteLine();
}
}
}
/// <inheritdoc />
public IEnumerable <Component> FindComponents()
{
MSBuildWorkspace msWorkspace = MSBuildWorkspace.Create();
Solution solution = msWorkspace.OpenSolutionAsync(PathToSolution).Result;
Project project = solution.Projects.Where(p => p.Name == ProjectName).First();
Compilation compilation = project.GetCompilationAsync().Result;
foreach (Component component in ComponentFinder.Container.Components)
{
foreach (CodeElement codeElement in component.CodeElements)
{
try
{
string type = codeElement.Type.Substring(0, component.Type.IndexOf(',')); // remove the assembly name from the type
INamedTypeSymbol symbol = compilation.GetTypeByMetadataName(type);
foreach (Microsoft.CodeAnalysis.Location location in symbol.Locations)
{
if (location.IsInSource)
{
codeElement.Url = new Uri(location.SourceTree.FilePath).AbsoluteUri;
codeElement.Size += location.SourceTree.GetText().Lines.Count;
component.Size += codeElement.Size;
}
}
if (codeElement.Role == CodeElementRole.Primary)
{
string xml = symbol.GetDocumentationCommentXml();
if (xml != null && xml.Trim().Length > 0)
{
XDocument xdoc = XDocument.Parse(xml);
string comment = xdoc.Descendants("summary").First().Value.Trim();
component.Description = comment;
}
}
}
catch (Exception e)
{
Console.WriteLine("Could not get summary comment for " + component.Name + ": " + e.Message);
}
}
}
return(new HashSet <Component>());
}
public async Task WriteDto_ExistingSolution_CityDTORewrite2()
{
var msWorkspace = MSBuildWorkspace.Create();
var solution = msWorkspace.OpenSolutionAsync(this.TestSolution.FullName).Result;
solution = solution.GetIsolatedSolution();
var cityDoc = solution.Projects
.SelectMany(p => p.Documents)
.Where(p => p.Name == "City.cs")
.FirstOrDefault();
var existingDto = solution.Projects
.SelectMany(p => p.Documents)
.Where(p => p.Name == "CityDTO.cs")
.FirstOrDefault();
var dtoLocation = solution.GetMostLikelyDtoLocation();
var vm = await PropertySelectorViewModel.Create(cityDoc, "CityDTO", dtoLocation, existingDto);
var countryProp = vm.EntityModel.Properties.Where(p => p.Name == "Country").FirstOrDefault();
Assert.IsNotNull(countryProp);
Assert.IsTrue(countryProp.RelatedEntity.Properties.Where(p => p.Name == "Code").Any(p => p.IsSelected));
Assert.IsFalse(countryProp.RelatedEntity.Properties.Where(p => p.Name == "Name").Any(p => p.IsSelected));
var modifiedSolution = await solution.WriteDto(dtoLocation, vm.GetMetadata(), true, false, false);
Assert.IsNotNull(modifiedSolution);
var cityDto = modifiedSolution.GetChanges(solution)
.GetProjectChanges().Single()
.GetChangedDocuments()
.Select(p => modifiedSolution.GetProject(p.ProjectId).GetDocument(p))
.Where(p => p.Name == "CityDTO.cs")
.FirstOrDefault();
Assert.IsNotNull(cityDto);
var source = await cityDto.GetTextAsync();
var sourceCode = source.ToString();
Assert.IsTrue(sourceCode.Contains("public string CountryCode { get; set; }"));
}
public async Task WriteDto_ExistingSolution_FishWithIdOverride()
{
var msWorkspace = MSBuildWorkspace.Create();
var solution = msWorkspace.OpenSolutionAsync(this.TestSolution.FullName).Result;
solution = solution.GetIsolatedSolution();
var fishClassDoc = solution.Projects
.SelectMany(p => p.Documents)
.Where(p => p.Name == "Fish.cs")
.FirstOrDefault();
var vm = await EntityViewModel.CreateRecursive(fishClassDoc);
vm.DtoName = "FishDTO";
var dtoLocation = solution.GetMostLikelyDtoLocation();
var modifiedSolution = await solution.WriteDto(dtoLocation, vm.ConvertToMetadata(), true, false, false);
Assert.IsNotNull(modifiedSolution);
var changeSet = modifiedSolution.GetChanges(solution);
Assert.AreEqual(1, changeSet.GetProjectChanges().Count());
var projectChanges = changeSet.GetProjectChanges().Single();
Assert.AreEqual(2, projectChanges.GetAddedDocuments().Count());
var addedDocs = projectChanges
.GetAddedDocuments()
.Select(p => modifiedSolution.GetProject(p.ProjectId).GetDocument(p));
var fishDto = addedDocs
.Where(p => p.Name == "FishDTO.cs")
.FirstOrDefault();
Assert.IsNotNull(fishDto);
var source = await fishDto.GetTextAsync();
var sourceCode = source.ToString();
Assert.IsTrue(sourceCode.IndexOf("public int Id { get; set; }") > 0);
Assert.AreEqual(sourceCode.IndexOf("public int Id { get; set; }"), sourceCode.LastIndexOf("public int Id { get; set; }"));
}
static void Main(string[] args)
{
// The test solution is copied to the output directory when you build this sample.
MSBuildWorkspace workspace = MSBuildWorkspace.Create();
// Open the solution within the workspace.
Solution originalSolution = workspace.OpenSolutionAsync(@"TestSolutionForCSharp\Test.sln").Result;
// Declare a variable to store the intermediate solution snapshot at each step.
Solution newSolution = originalSolution;
// Note how we can't simply iterate over originalSolution.Projects or project.Documents
// because it will return objects from the unmodified originalSolution, not from the newSolution.
// We need to use the ProjectIds and DocumentIds (that don't change) to look up the corresponding
// snapshots in the newSolution.
foreach (ProjectId projectId in originalSolution.ProjectIds)
{
// Look up the snapshot for the original project in the latest forked solution.
Project project = newSolution.GetProject(projectId);
foreach (DocumentId documentId in project.DocumentIds)
{
// Look up the snapshot for the original document in the latest forked solution.
Document document = newSolution.GetDocument(documentId);
// Get a transformed version of the document (a new solution snapshot is created
// under the covers to contain it - none of the existing objects are modified).
Document newDocument = Formatter.FormatAsync(document).Result;
// Store the solution implicitly constructed in the previous step as the latest
// one so we can continue building it up in the next iteration.
newSolution = newDocument.Project.Solution;
}
}
// Actually apply the accumulated changes and save them to disk. At this point
// workspace.CurrentSolution is updated to point to the new solution.
if (workspace.TryApplyChanges(newSolution))
{
Console.WriteLine("Solution updated.");
}
else
{
Console.WriteLine("Update failed!");
}
}
public static async Task <Document> FixSourceAsync(string documentPath, string diagnosticId)
{
if (documentPath is null)
{
throw new ArgumentNullException(nameof(documentPath));
}
using var workspace = MSBuildWorkspace.Create();
var project = await workspace.OpenProjectAsync(TestProjectPath).ConfigureAwait(false);
var projectId = project.Id;
var diagnosticFixed = false;
var solution = workspace.CurrentSolution;
const int MAX_TRIES = 100;
var fixAttempts = 0;
do
{
fixAttempts++;
diagnosticFixed = false;
project = solution.GetProject(projectId) !;
var diagnostics = await GetDiagnosticsFromProjectAsync(project, documentPath, diagnosticId).ConfigureAwait(false);
foreach (var diagnostic in diagnostics)
{
var doc = project.GetDocument(diagnostic.Location.SourceTree) !;
var fixedSolution = await TryFixDiagnosticAsync(diagnostic, doc).ConfigureAwait(false);
if (fixedSolution != null)
{
solution = fixedSolution;
diagnosticFixed = true;
break;
}
}
if (fixAttempts + 1 == MAX_TRIES)
{
Assert.True(false, $"The code fixers were unable to resolve the following diagnostic(s):{Environment.NewLine} {string.Join(',', diagnostics.Select(d => d.Id))}");
}
}while (diagnosticFixed);
project = solution.GetProject(projectId) !;
return(project.Documents.First(d => documentPath.Equals(Path.GetFileName(d.FilePath), StringComparison.Ordinal)));
}
public async Task MeasureSolutionAnalysisPerformance()
{
using (var workspace = MSBuildWorkspace.Create())
{
var path = @"..\..\..\..\archimetrics.sln".GetLowerCaseFullPath();
var solution = await workspace.OpenSolutionAsync(path).ConfigureAwait(false);
var metrics = new metrics.Metrics();
var timer = metrics.Timer(GetType(), "test", TimeUnit.Seconds, TimeUnit.Seconds);
for (var i = 0; i < 5; i++)
{
var amount = timer.Time(() => PerformReview(solution).Result);
}
Assert.True(timer.Mean < 90.0);
}
}
public static void ExampleOne()
{
var work = MSBuildWorkspace.Create();
var solution = work.OpenSolutionAsync(@"..\..\..\RoslynPlayGround.sln").Result;
var project = solution.Projects.FirstOrDefault(p => p.Name == "Chapter3");
if (project == null)
{
throw new Exception("Could not find the Chapter 3 project");
}
var compilation = project.GetCompilationAsync().Result;
var targetType = compilation.GetTypeByMetadataName("Chapter3.IGreetingProfile");
var type = Symbols.FindClassesDerivedOrImplementedByType(compilation, targetType);
Console.WriteLine(type.First().Identifier.ToFullString());
}
public async Task MeasureProjectAnalysisPerformance()
{
using (var workspace = MSBuildWorkspace.Create())
{
var path = @"..\..\..\ArchiMetrics.Common\ArchiMetrics.Common.csproj".GetLowerCaseFullPath();
var project = await workspace.OpenProjectAsync(path).ConfigureAwait(false);
var metrics = new metrics.Metrics();
var timer = metrics.Timer(GetType(), "test", TimeUnit.Seconds, TimeUnit.Seconds);
for (var i = 0; i < 5; i++)
{
var amount = timer.Time(() => PerformReview(project).Result);
}
Assert.Less(timer.Mean, 90.0);
}
}
private static async Task GenerateWithMSBuildLocatedAsync(
FileInfo solutionOrProjectFile, ILsifJsonWriter lsifWriter, TextWriter logFile,
Func <MSBuildWorkspace, Task <Solution> > openAsync)
{
await logFile.WriteLineAsync($"Loading {solutionOrProjectFile.FullName}...");
var solutionLoadStopwatch = Stopwatch.StartNew();
var msbuildWorkspace = MSBuildWorkspace.Create();
msbuildWorkspace.WorkspaceFailed += (s, e) => logFile.WriteLine("Error while loading: " + e.Diagnostic.Message);
var solution = await openAsync(msbuildWorkspace);
await logFile.WriteLineAsync($"Load completed in {solutionLoadStopwatch.Elapsed.ToDisplayString()}.");
var lsifGenerator = Generator.CreateAndWriteCapabilitiesVertex(lsifWriter);
var totalTimeInGenerationAndCompilationFetchStopwatch = Stopwatch.StartNew();
var totalTimeInGenerationPhase = TimeSpan.Zero;
foreach (var project in solution.Projects)
{
if (project.SupportsCompilation && project.FilePath != null)
{
var compilationCreationStopwatch = Stopwatch.StartNew();
var compilation = (await project.GetCompilationAsync()) !;
await logFile.WriteLineAsync($"Fetch of compilation for {project.FilePath} completed in {compilationCreationStopwatch.Elapsed.ToDisplayString()}.");
var generationForProjectStopwatch = Stopwatch.StartNew();
await lsifGenerator.GenerateForCompilationAsync(compilation, project.FilePath, project.LanguageServices, project.Solution.Options);
generationForProjectStopwatch.Stop();
totalTimeInGenerationPhase += generationForProjectStopwatch.Elapsed;
await logFile.WriteLineAsync($"Generation for {project.FilePath} completed in {generationForProjectStopwatch.Elapsed.ToDisplayString()}.");
}
}
await logFile.WriteLineAsync($"Total time spent in the generation phase for all projects, excluding compilation fetch time: {totalTimeInGenerationPhase.ToDisplayString()}");
await logFile.WriteLineAsync($"Total time spent in the generation phase for all projects, including compilation fetch time: {totalTimeInGenerationAndCompilationFetchStopwatch.Elapsed.ToDisplayString()}");
}
public ExtractMetadataWorker(ExtractMetadataInputModel input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (string.IsNullOrEmpty(input.OutputFolder))
{
throw new ArgumentNullException(nameof(input.OutputFolder), "Output folder must be specified");
}
_files = input.Files?.Select(s => new FileInformation(s))
.GroupBy(f => f.Type)
.ToDictionary(s => s.Key, s => s.Distinct().ToList());
_rebuild = input.ForceRebuild;
var msbuildProperties = input.MSBuildProperties ?? new Dictionary <string, string>();
if (!msbuildProperties.ContainsKey("Configuration"))
{
msbuildProperties["Configuration"] = "Release";
}
_options = new ExtractMetadataOptions
{
ShouldSkipMarkup = input.ShouldSkipMarkup,
PreserveRawInlineComments = input.PreserveRawInlineComments,
FilterConfigFile = input.FilterConfigFile != null ? new FileInformation(input.FilterConfigFile).NormalizedPath : null,
MSBuildProperties = msbuildProperties,
};
_useCompatibilityFileName = input.UseCompatibilityFileName;
_outputFolder = StringExtension.ToNormalizedFullPath(Path.Combine(EnvironmentContext.OutputDirectory, input.OutputFolder));
_workspace = new Lazy <MSBuildWorkspace>(() =>
{
var workspace = MSBuildWorkspace.Create(msbuildProperties);
workspace.WorkspaceFailed += (s, e) =>
{
Logger.LogWarning($"Workspace failed with: {e.Diagnostic}");
};
return(workspace);
});
}
public async Task <IntertypeRelationGraph> GetDataStructure(TCSharpModel model, CancellationToken token)
{
var graph = new IntertypeRelationGraph();
var workspace = MSBuildWorkspace.Create(new Dictionary <string, string>
{
{ "Configuration", settingsProvider.Configuration },
{ "Platform", settingsProvider.Platform }
});
var solution = await workspace.OpenSolutionAsync(model.AbsoluteSolutionPath, token);
compilations = new List <Compilation>();
var typeSymbols = new List <INamedTypeSymbol>();
//Collect all types
foreach (var project in solution.Projects)
{
token.ThrowIfCancellationRequested();
var compilation = await project.GetCompilationAsync(token);
compilations.Add(compilation);
foreach (var namespaceSymbol in compilation.Assembly.GlobalNamespace.GetNamespaceMembers())
{
AddNodeIfNotExists(namespaceSymbol, graph, typeSymbols);
}
}
//Build edges
var parallelOptions = new ParallelOptions
{
CancellationToken = token,
MaxDegreeOfParallelism = Environment.ProcessorCount
};
Parallel.ForEach(typeSymbols, parallelOptions, type =>
{
parallelOptions.CancellationToken.ThrowIfCancellationRequested();
ProcessTypeSymbol(type, graph);
});
return(graph);
}
private static void Method6()
{
var work = MSBuildWorkspace.Create();
var solution = work.OpenSolutionAsync(@"..\..\..\RoslynPlayGround.sln").Result;
var project = solution.Projects.FirstOrDefault(p => p.Name == "CodeGenerationWithRoslyn");
if (project == null)
{
throw new Exception("Could not find the CodeGenerationWithRoslyn Project");
}
var compilation = project.GetCompilationAsync().Result;
// Do something with the compilation
var memory = new MemoryStream();
var results = compilation.Emit(memory);
if (!results.Success)
{
foreach (var item in results.Diagnostics)
{
if (item.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error)
{
Console.WriteLine(item.GetMessage());
}
}
}
var assembly = Assembly.Load(memory.ToArray());
var types = assembly.GetTypes();
var greetingRules = types.FirstOrDefault(t => t.Name == "GreetingRules");
if (greetingRules == null)
{
throw new Exception("Could not find the type, GreetingRules");
}
foreach (var method in greetingRules.GetMethods(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public))
{
Console.WriteLine(method.Name);
}
}
static void Main()
{
var @namespace = NamespaceDeclaration(IdentifierName("HearthDb"));
var header = ParseLeadingTrivia(@"/* THIS CLASS WAS GENERATED BY HearthDb.CardIdGenerator. DO NOT EDIT. */");
var cCardIds = ClassDeclaration("CardIds").AddModifiers(Token(PublicKeyword)).WithLeadingTrivia(header);
var cCollectible = ClassDeclaration("Collectible").AddModifiers(Token(PublicKeyword));
cCollectible = SyntaxBuilder.GetCollectible(cCollectible);
var cNonCollectible = SyntaxBuilder.GetNonCollectible();
cCardIds = cCardIds.AddMembers(cCollectible);
cCardIds = cCardIds.AddMembers(cNonCollectible);
@namespace = @namespace.AddMembers(cCardIds);
var root = Formatter.Format(@namespace, MSBuildWorkspace.Create());
using (var sr = new StreamWriter(File))
sr.Write(root.ToString());
}
// Note: $var with "Name" doesn't need to be path, but $var without "Name" should be the exact path
public Utility(string sln, string testProjectName, string testFileName)
{
Debug.Assert(File.Exists(sln));
this.workspace = MSBuildWorkspace.Create();
this.solution = workspace.OpenSolutionAsync(sln).Result;
//Console.WriteLine(testProjectName);
Document testClassDocument = FindDocumentByName(testProjectName, testFileName);
//Environment.Exit(0);
/**** DEBUG ****/
Debug.Assert(testClassDocument != null);
this.testClassEditor = DocumentEditor.CreateAsync(testClassDocument).Result;
this.testClassTree = testClassDocument.GetSyntaxTreeAsync().Result;
SyntaxNode testClassRoot = testClassTree.GetRoot();
this.testClassMethods = testClassRoot.DescendantNodes().OfType <MethodDeclarationSyntax>().ToList();
}
private static void SearchFeatureToggleKeywodInSolution(string solutionPath, string featureToggle)
{
var msWorkspace = MSBuildWorkspace.Create();
var solution = msWorkspace.OpenSolutionAsync(solutionPath).Result;
foreach (var project in solution.Projects)
{
foreach (var document in project.Documents)
{
var syntaxRoot = document.GetSyntaxRootAsync();
if (syntaxRoot.ToString().Contains(featureToggle))
{
Console.WriteLine(project.Name + "\t\t\t" + document.FilePath);
}
}
}
}
public static async Task Main(string[] args)
{
MSBuildLocator.RegisterDefaults();
var workspace = MSBuildWorkspace.Create();
var proj = await workspace.OpenProjectAsync(args[0]);
foreach (var x in workspace.Diagnostics)
{
Debug.WriteLine(x);
}
proj = Mapping.ProcessProject(proj);
if (!workspace.TryApplyChanges(proj.Solution))
{
Debug.Fail("");
}
;
}
public void AssertCodeFixTransformsTo(string preCodeFix, string expectedPostCodeFix, Func <ClassDeclarationSyntax, ClassDeclarationSyntax> fixCode)
{
var workspace = MSBuildWorkspace.Create();
SyntaxTree astPreCodeFix = CSharpSyntaxTree.ParseText(preCodeFix);
var rootPreCodeFix = ( CompilationUnitSyntax )astPreCodeFix.GetRoot();
var classPreCodeFix = rootPreCodeFix.ChildNodes().OfType <ClassDeclarationSyntax>().First();
var classPostCodeFix = fixCode(classPreCodeFix);
var astPostCodeFixFormattedStr = Formatter.Format(classPostCodeFix, workspace).ToFullString();
SyntaxTree astExpectedPostCodeFix = CSharpSyntaxTree.ParseText(expectedPostCodeFix);
var rootExpectedPostCodeFix = ( CompilationUnitSyntax )astExpectedPostCodeFix.GetRoot();
var expectedClassPostCodeFix = rootExpectedPostCodeFix.ChildNodes().OfType <ClassDeclarationSyntax>().First();
var astExpectedPostCodeFixFormattedStr = Formatter.Format(expectedClassPostCodeFix, workspace).ToFullString();
Assert.AreEqual(astExpectedPostCodeFixFormattedStr, astPostCodeFixFormattedStr);
}
private static void EnsureOtherAssembliesLoad()
{
// force load msbuild and get its location
using var workspace = MSBuildWorkspace.Create();
var msbuild = AssemblyLoadContext.Default.Assemblies.Single(a => a.GetName().Name == "Microsoft.Build");
var msBuildLocation = Path.GetDirectoryName(msbuild.Location) ?? string.Empty;
// add a loader that will try and find the assembly in the same location if we didn't find it
AssemblyLoadContext.Default.Resolving += (AssemblyLoadContext arg1, System.Reflection.AssemblyName arg2) =>
{
var attemptedLocation = Path.Combine(msBuildLocation, arg2.Name + ".dll");
if (File.Exists(attemptedLocation))
{
return(Assembly.LoadFrom(attemptedLocation));
}
return(null);
};
}
public async Task TestTransformProject()
{
var workspace = MSBuildWorkspace.Create();
var project = await workspace.OpenProjectAsync(Path.Combine(AppContext.BaseDirectory, "../../../../TestAssembly/TestAssembly.csproj"));
var ass = await SharpCompiler.CompileProject(project);
Assert.NotNull(ass);
Assert.Equal("TestAssembly.Py", ass.GetName().Name);
var itemRecordType = ass.GetType("TestAssembly.item_record");
Assert.NotNull(itemRecordType);
Assert.NotNull(itemRecordType.GetProperty("name"));
Assert.NotNull(itemRecordType.GetProperty("description"));
Assert.NotNull(itemRecordType.GetProperty("current_ticks"));
}
public CompiledProject(string projectFilePath)
{
if (!File.Exists(projectFilePath))
{
var currentDirectory = Directory.GetCurrentDirectory();
throw new ArgumentException($"No project file exists at '{projectFilePath}'.");
}
// https://stackoverflow.com/a/64766792/7176908
MSBuildLocator.RegisterDefaults();
this.Workspace = MSBuildWorkspace.Create();
this.Workspace.LoadMetadataForReferencedProjects = true;
this.Project = this.Workspace.OpenProjectAsync(projectFilePath).Result;
this.Compilation = this.Project.GetCompilationAsync().Result;
}
public void Should_create_file_from_semantic_log_from_project()
{
var runner = new T4TemplateRunner();
var startDirectory = Path.Combine(FileSupport.ProjectPath(AppDomain.CurrentDomain.BaseDirectory), "..\\SemanticLogGenerationMetadata");
startDirectory = Path.GetFullPath(startDirectory);
var ws = MSBuildWorkspace.Create();
var projectPath = FileSupport.GetNearestCSharpProject(startDirectory);
// For now: wait for the result
var project = ws.OpenProjectAsync(projectPath).Result;
var dict = runner.CreateOutputStringsFromProject(project, "..\\Output");
Assert.AreEqual(1, dict.Count());
var actual = dict.First().Value;
actual = StringUtilities.RemoveFileHeaderComments(actual);
Assert.AreEqual(expected, actual);
}
private IEnumerable <string> GenerateDocumentsPaths()
{
var workspace = MSBuildWorkspace.Create();
var solution = workspace.OpenSolutionAsync(_solutionPath).Result;
foreach (var project in solution.Projects)
{
string projectPath = Path.GetDirectoryName(project.FilePath);
foreach (var document in project.Documents)
{
string documentPath = Path.GetDirectoryName(document.FilePath);
if (projectPath == documentPath)
{
yield return(document.FilePath);
}
}
}
}
public FeatureLookup(string solutionPath, IEnumerable <IFeatureQuery> queries)
{
this.projectFilter = _ => true;
this.queries = queries;
var properties = new Dictionary <string, string>
{
// This property ensures that XAML files will be compiled in the current AppDomain
// rather than a separate one. Any tasks isolated in AppDomains or tasks that create
// AppDomains will likely not work due to https://github.com/Microsoft/MSBuildLocator/issues/16.
{ "AlwaysCompileMarkupFilesInSeparateDomain", bool.FalseString }
};
this.workspace = MSBuildWorkspace.Create(properties);
this.workspace.WorkspaceFailed += Workspace_WorkspaceFailed;
this.solution = this.workspace.OpenSolutionAsync(solutionPath, new ProgressReporter()).Result;
}
public async Task <HashSet <string> > GetRecursivelyReferencedProjects(string solutionFilePath, string[] rootProjectNames)
{
var workspace = MSBuildWorkspace.Create();
var solution = workspace.OpenSolutionAsync(solutionFilePath).Result;
var references = new ConcurrentDictionary <string, object>();
var tasks = rootProjectNames
.Select(async(projName) =>
{
await FillReferencedProjectSetRecursively(solution, projName, references);
});
await Task.WhenAll(tasks);
return(new HashSet <string>(references.Keys));
}
public void ShowThisSolutionStructure()
{
String currentDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? ".";
MSBuildWorkspace workspace = MSBuildWorkspace.Create();
Solution solution = workspace.OpenSolutionAsync(Path.Combine(currentDir, "..//..//..//SourceCodeAnalysis.sln")).Result;
foreach (ProjectId projectId in solution.GetProjectDependencyGraph().GetTopologicallySortedProjects())
{
Project project = solution.GetProject(projectId);
String projectRoot = Path.GetDirectoryName(project.FilePath) + "\\";
Console.WriteLine("project : {0}, path : {1}", project.Name, project.FilePath);
foreach (Document document in project.Documents)
{
Console.WriteLine(" file : {0}", document.FilePath.Substring(projectRoot.Length));
}
Console.WriteLine();
}
}
public static MSBuildWorkspace CreateMSBuildWorkspace()
{
try
{
MSBuildLocator.RegisterDefaults();
}
catch
{
Console.WriteLine("Workspace defaults already registered");
}
MSBuildWorkspace workspace = MSBuildWorkspace.Create(new Dictionary <string, string> {
{ "DebugSymbols", "False" }
});
workspace.WorkspaceFailed += (e, d) => Console.WriteLine(e.ToString() + ":" + d.ToString());
return(workspace);
}
protected override async Task ExecuteAsync(string[] args)
{
_args = args;
var workspace = MSBuildWorkspace.Create();
var solutionFileName = args[1];
Solution originalSolution = await workspace.OpenSolutionAsync(solutionFileName);
Solution newSolution = await ReplaceDocumentsAsync(originalSolution, ProcessDocumentAsync);
if (workspace.TryApplyChanges(newSolution))
{
Console.WriteLine("Solution updated.");
}
else
{
Console.WriteLine("Update failed!");
}
}
public static MSBuildWorkspace CreateWorkspace(Dictionary <string, string>?properties)
{
if (properties is null)
{
properties = new Dictionary <string, string>();
}
#if NETCOREAPP
// This property ensures that XAML files will be compiled in the current AppDomain
// rather than a separate one. Any tasks isolated in AppDomains or tasks that create
// AppDomains will likely not work due to https://github.com/Microsoft/MSBuildLocator/issues/16.
properties["AlwaysCompileMarkupFilesInSeparateDomain"] = bool.FalseString;
#endif
// Use the latest language version to force the full set of available analyzers to run on the project.
properties["LangVersion"] = "latest";
return(MSBuildWorkspace.Create(properties));
}