public virtual Task AddReferenceAsync(string referencePath)
{
string fullPath = PathUtility.GetAbsolutePath(ProjectFullPath, referencePath);
string relativePath = PathUtility.GetRelativePath(ProjectFileFullPath, fullPath);
string assemblyFileName = Path.GetFileNameWithoutExtension(fullPath);
try
{
var assemblyName = AssemblyName.GetAssemblyName(fullPath);
assemblyFileName = assemblyName.FullName;
}
catch
{
// no-op
}
MsBuildProject.AddItem(
"Reference",
assemblyFileName,
new KeyValuePair <string, string>[] {
new KeyValuePair <string, string>("HintPath", relativePath),
new KeyValuePair <string, string>("Private", "True")
});
return(Task.CompletedTask);
}
public override void AddProjectToSolution(string projectFullPath)
{
var msbuildProj = MsBuildProject.Load(projectFullPath);
var solutionFile = MSBuildSolution.Create(SolutionPath);
solutionFile.AddProjectToSolution(msbuildProj.Name, msbuildProj.Guid);
}
static bool ConvertProject(string pathToProject)
{
var xmlProject = MsBuildProject.Load(pathToProject);
bool ok = (xmlProject != null);
if (ok)
{
ok = xmlProject.AddQtMsBuildReferences();
}
if (ok)
{
ok = xmlProject.ConvertCustomBuildToQtMsBuild();
}
if (ok)
{
ok = xmlProject.EnableMultiProcessorCompilation();
}
if (ok)
{
ok = xmlProject.UpdateProjectFormatVersion();
}
if (ok)
{
ok = xmlProject.Save();
}
// Initialize Qt variables
if (ok)
{
xmlProject.BuildTarget("QtVarsDesignTime");
}
return(ok);
}
public Project(StructEx.Solution solution, string title, string fileName) : base(solution, title, fileName)
{
Files = new List <File>();
ProjectContent = new CSharpProjectContent();
ResolvedReferencedAssemblies = new List <IUnresolvedAssembly>();
ProjectContent = ProjectContent.SetAssemblyName(AssemblyName);
ProjectContent = ProjectContent.SetProjectFileName(fileName);
ProjectContent = ProjectContent.SetCompilerSettings(Utils.Convert.ToCompilerSettings(CompilerSettings));
foreach (var sourceCodeFile in MsBuildProject.GetItems("Compile"))
{
Files.Add(new File(this, Path.Combine(MsBuildProject.DirectoryPath, sourceCodeFile.EvaluatedInclude)));
}
var files =
Files.Select(f => f.UnresolvedTypeSystemForFile);
ProjectContent = ProjectContent.AddOrUpdateFiles(files);
foreach (var projectReference in ReferencedProjects)
{
ProjectContent = ProjectContent.AddAssemblyReferences(new[] { new ProjectReference(projectReference) });
}
ResolveAssemblies();
}
public override void AddItems(params string[] itemsFullPath)
{
if (itemsFullPath == null || itemsFullPath.Length == 0)
{
return;
}
var projectFileName = FindProject(GenContext.Current.OutputPath);
if (string.IsNullOrEmpty(projectFileName))
{
throw new Exception($"There is not project file in {GenContext.Current.OutputPath}");
}
var msbuildProj = MsBuildProject.Load(projectFileName);
if (msbuildProj != null)
{
foreach (var item in itemsFullPath)
{
msbuildProj.AddItem(item);
}
msbuildProj.Save();
}
}
public AuditProject(IProject roslynProject, FrameworkName targetFramework, Options options)
{
// Shared
RoslynProject = roslynProject;
MsBuildProject = RoslynProject.GetMsBuildProject();
LocalRepository = RoslynProject.Solution.GetLocalPackageRepository();
ConfigReferences = PackageReferenceFile.CreateFromProject(RoslynProject.FilePath).GetPackageReferences(false).ToList();
CsprojReferences = MsBuildProject.GetDirectPackageAssemblies().Select(g => g.Key).Where(r => r != null).Distinct().ToList();
References = ConfigReferences.Union(CsprojReferences).ToList();
Packages = options.Unused || options.Snapshot || options.Missing || options.Project
? References.Select(r => r.GetPackage(LocalRepository)).Where(p => p != null).ToList()
: Enumerable.Empty <IPackage>();
// Unused Packages
UnusedPackages = options.Unused
? GetUnusedPackages(targetFramework, options.UnusedUsings)
: Enumerable.Empty <UnusedPackage>();
// Snapshot References
SnapshotPackages = options.Snapshot
? Packages.GetSnapshotPackages()
: Enumerable.Empty <SnapshotPackage>();
// Missing Packages
MissingPackages = options.Missing
? GetMissingPackages(targetFramework)
: Enumerable.Empty <MissingPackageDependency>();
// Project Packages
ProjectPackages = options.Project
? GetProjectPackages()
: Enumerable.Empty <ProjectPackage>();
// File Diff References
MissingPackageReferences = options.FileDiff
? GetMissingPackageReferences()
: Enumerable.Empty <InconsistentFiles>();
// Duplicate Package References
DuplicatePackageReferences = options.FileDiff
? GetDuplicatePackageReferences()
: Enumerable.Empty <DuplicatePackageReference>();
// Orphan Binding Redirects
BindingRedirectOnlyReferences = options.FileDiff
? GetBindingRedirectOnlyReferences()
: Enumerable.Empty <OrphanAssemblyBinding>();
// Mismatched Binding Redirects
BindingRedirectMismatchReferences = options.RedirectMismatch
? GetBindingRedirectMismatchReferences()
: Enumerable.Empty <MismatchAssemblyBinding>();
BadProjectRefGuids = options.FileDiff
? GetBadProjectRefGuids()
: Enumerable.Empty <MismatchedGuid>();
IllegalNugetTargets = options.NugetTargets
? GetIllegalNugetTargets()
: Enumerable.Empty <IllegalProjectFileElement>();
}
void UpdataBuildConfigOfProject(MsBuildProject project)
{
project.BuildConfiguration = FBuildConfigIn[0];
if (IsProjectInUse(project))
{
project.CompileAsync();
}
}
private IEnumerable <OrphanOrMismatchAssemblyBinding> GetBindingRedirectMismatchReferences()
{
var allAssemblyIds = GetAllAssemblyReferences().SelectMany(p => p).ToDictionary(k => k.Key, v => v.Value);
return(MsBuildProject.GetBindingRedirects()
.Where(br => !(allAssemblyIds.ContainsKey(br.Name) && allAssemblyIds[br.Name].Equals(br.NewVersion)))
.Select(br => new OrphanOrMismatchAssemblyBinding(br)));
}
private IEnumerable <MismatchedGuid> GetBadProjectRefGuids()
{
var solutionProjects = SolutionFile.FromFile(RoslynProject.Solution.FilePath).Projects;
return(MsBuildProject.GetProjectReferences()
.Where(r => !r.EqualByGuid(GetSolutionProjectFromProjectReference(r, solutionProjects)))
.Select(r => new MismatchedGuid(r.GetProjectGuid(), r.GetProjectName(), "Project Reference")));
}
private IEnumerable <OrphanAssemblyBinding> GetBindingRedirectOnlyReferences()
{
var allAssemblyIds = GetAllAssemblyReferences().SelectMany(p => p).Select(k => k.Key).ToHashSet();
return(MsBuildProject.GetBindingRedirects()
.Where(br => !allAssemblyIds.Contains(br.Name))
.Select(br => new OrphanAssemblyBinding(br)));
}
public virtual void RemoveImport(string targetFullPath)
{
if (targetFullPath == null)
{
throw new ArgumentNullException("targetFullPath");
}
MsBuildProject.RemoveImport(targetFullPath);
}
protected virtual void AddFileToProject(string path)
{
if (!ExcludeFile(path))
{
MsBuildProject.AddItem("Content", path);
NuGetProjectContext.Log(MessageLevel.Debug, "AddedFileToProject", path, ProjectName);
}
}
public virtual void AddImport(string targetFullPath, ImportLocation location)
{
if (targetFullPath == null)
{
throw new ArgumentNullException("targetFullPath");
}
MsBuildProject.AddImport(targetFullPath, location == ImportLocation.Top ? true : false);
}
private MsBuildProject OpenMsBuildProject(string filename)
{
var msBuildProject = MsBuildProject.Deserialize(filename, Terminal.HandleException);
if (msBuildProject == null)
{
FileOpenFailed("MsBuild Project", filename);
}
return(msBuildProject);
}
public virtual IEnumerable <string> GetFullPaths(string fileName)
{
foreach (var projectItem in MsBuildProject.GetItems())
{
var itemFileName = Path.GetFileName(projectItem.EvaluatedInclude);
if (string.Equals(fileName, itemFileName, StringComparison.OrdinalIgnoreCase))
{
yield return(Path.Combine(ProjectFullPath, projectItem.EvaluatedInclude));
}
}
}
/// <summary>
/// Called by AbstractFileFactory to extract all node infos in given file.
/// </summary>
protected override IEnumerable <INodeInfo> LoadNodeInfos(string filename)
{
var nodeInfos = new List <INodeInfo>();
// We can't handle dynamic plugins
if (!MsBuildProject.IsDynamicAssembly(filename))
{
LoadNodeInfosFromFile(filename, filename, ref nodeInfos, true);
}
return(nodeInfos);
}
public override string GetActiveProjectGuid()
{
var projectFileName = FindProject(GenContext.Current.ProjectPath);
if (string.IsNullOrEmpty(projectFileName))
{
throw new Exception($"There is not project file in {GenContext.Current.ProjectPath}");
}
var msbuildProj = MsBuildProject.Load(projectFileName);
return(msbuildProj.Guid);
}
private IEnumerable <DuplicatePackageReference> GetDuplicatePackageReferences()
{
var configDuplicates = ConfigReferences
.Duplicates()
.Select(r => new DuplicatePackageReference(r, "packages.config"));
var csprojDuplicates = MsBuildProject.GetDirectPackageAssemblies()
.SelectMany(p => p, (grouping, s) => new { grouping, s })
.DuplicatesBy(a => a.s)
.Select(r => new DuplicatePackageReference(r.grouping.Key, ".csproj", r.s.Key));
return(configDuplicates.Concat(csprojDuplicates));
}
private IEnumerable <MissingPackageDependency> GetMissingPackages(FrameworkName targetFramework)
{
// All dependencies of all packages ...
return(Packages.SelectMany(p => p.GetCompatiblePackageDependencies(targetFramework),
(package, dependency) => new { package, dependency })
// ... that aren't installed as a package ...
.Where(d => !Packages.Select(p => p.Id).Contains(d.dependency.Id))
// ... or as a project
.Where(d => !MsBuildProject.GetProjectReferenceNames().Contains(d.dependency.Id))
// Dependencies don't have good equality checking
.GroupBy(d => d.dependency.ToString())
.Select(g => new MissingPackageDependency(g.First().dependency, g.Select(d => d.package))));
}
public virtual Task RemoveReferenceAsync(string name)
{
name = Path.GetFileNameWithoutExtension(name);
dynamic item = GetReference(name);
if (item != null)
{
MsBuildProject.RemoveItem(item);
}
return(Task.CompletedTask);
}
public virtual void RemoveFile(string path)
{
if (!string.IsNullOrEmpty(path))
{
var files = MsBuildProject.GetItemsByEvaluatedInclude(path);
if (files != null)
{
MsBuildProject.RemoveItems(files);
NuGetProjectContext.Log(MessageLevel.Debug, "RemovedFileToProject", path, ProjectName);
}
FileSystemUtility.DeleteFileAndParentDirectoriesIfEmpty(ProjectFullPath, path, NuGetProjectContext);
}
}
public IReadOnlyDictionary <string, IEvaluatedProjectPropertyValue> EvaluateProperties(Dictionary <string, string> propertyValues = null)
{
var result = new Dictionary <string, IEvaluatedProjectPropertyValue>();
using (new MsBuildConditionContext(MsBuildProject, propertyValues))
{
foreach (var property in Properties.Values)
{
var projectPropertyElement = MsBuildProject.GetProperty(property.Name)?.Xml;
if (projectPropertyElement != null)
{
result.Add(
property.Name,
new EvaluatedProjectPropertyValue(projectPropertyElement.Value, new ProjectPropertyOccurrence(projectPropertyElement)));
}
}
}
return(result);
}
private IEnumerable <UnusedPackage> GetUnusedPackages(FrameworkName targetFramework, bool lookAtUnusedUsings)
{
var usedAssemblyPaths = RoslynProject.Documents
.SelectMany(d => d.GetUsedAssemblies(lookAtUnusedUsings))
.Select(a => a.Identity.Location)
.Where(p => !string.IsNullOrEmpty(p))
.Distinct().ToList();
return(Packages
// Packages not referenced by other packages ...
.GetDirectPackages(targetFramework)
// ... that have assemblies ...
.Where(p => p.AssemblyReferences.Any())
// ... and the namespaces in those assemblies do not exist in the project ...
.Where(p => p.GetTypes().Select(t => t.FullName).Intersect(MsBuildProject.GetNamespaces()).IsEmpty())
// ... and the assemblies are not used by symbols in the project
.Where(p => !p.GetAssemblyPaths().Any(a => usedAssemblyPaths.Any(u => u.Contains(a))))
.Where(p => !p.Id.Equals("Aspose.Words")) // Roslyn seems to have a problem with this package
.Select(p => new UnusedPackage(p)));
}
public Result.IfSuccess <MsBuildProject> TryUpdateAsync(MsBuildProject msBuildProject, IEnumerable <PackageUpdate> packageUpdates)
{
var fileContent = msBuildProject.ProjectContent;
var wasModified = false;
foreach (var packageId in packageUpdates)
{
var regex = new Regex(string.Format(MsBuildProjectPackagesParser.PackageReferenceRegex, GlobRegex.ConvertToRegexPattern(packageId.Id).Expression));
fileContent = regex.Replace(
fileContent,
m =>
{
wasModified = true;
return(m.Groups[PrefixGroupName].Value + packageId.UpdatedNuGetVersion.ToFullString() + m.Groups[PostfixGroupName].Value);
});
}
this.packageVersionUpdaterReporter.ProcessedProject(msBuildProject.Path, wasModified);
return(Result.FromValue(wasModified, msBuildProject with {
ProjectContent = fileContent
}));
private void ImportQMakeProject(FileInfo projectFile, VersionInformation vi)
{
var xmlProject = MsBuildProject.Load(projectFile.FullName);
xmlProject.ReplacePath(vi.qtDir, "$(QTDIR)");
xmlProject.ReplacePath(projectFile.DirectoryName, ".");
bool ok = xmlProject.AddQtMsBuildReferences();
if (ok)
{
ok = xmlProject.ConvertCustomBuildToQtMsBuild();
}
if (ok)
{
ok = xmlProject.EnableMultiProcessorCompilation();
}
if (ok)
{
string versionWin10SDK = HelperFunctions.GetWindows10SDKVersion();
if (!string.IsNullOrEmpty(versionWin10SDK))
{
ok = xmlProject.SetDefaultWindowsSDKVersion(versionWin10SDK);
}
}
if (ok)
{
ok = xmlProject.UpdateProjectFormatVersion();
}
if (!ok)
{
Messages.Print(
SR.GetString("ImportProject_CannotConvertProject", projectFile.Name));
}
xmlProject.Save();
// Initialize Qt variables
xmlProject.BuildTarget("QtVarsDesignTime");
}
static bool ConvertProject(string pathToProject)
{
var xmlProject = MsBuildProject.Load(pathToProject);
bool ok = (xmlProject != null);
if (ok)
{
ok = xmlProject.AddQtMsBuildReferences();
}
if (ok)
{
ok = xmlProject.ConvertCustomBuildToQtMsBuild();
}
if (ok)
{
ok = xmlProject.EnableMultiProcessorCompilation();
}
if (ok)
{
ok = xmlProject.Save();
}
return(ok);
}
protected MsBuildProject?ResolveProject(string?project)
{
//builder.Register(c =>
//{
// MsBuildProject msBuild = MsBuildProject.FromFileOrDirectory(ProjectCollection.GlobalProjectCollection, fileOrDirectory);
// return new DotNetProjectInformationProvider(msBuild);
//}).As<IProjectInformationProvider>();
if (project == null)
{
project = Directory.GetCurrentDirectory();
project = PathUtility.EnsureTrailingSlash(project);
}
try
{
return(MsBuildProject.FromFileOrDirectory(ProjectCollection.GlobalProjectCollection, project));
}
catch
{
return(null);
}
}
public void RunStarted(object automation, Dictionary <string, string> replacements,
WizardRunKind runKind, object[] customParams)
{
var serviceProvider = new ServiceProvider(automation as IServiceProvider);
var iVsUIShell = serviceProvider.GetService(typeof(SVsUIShell)) as IVsUIShell;
iVsUIShell.EnableModeless(0);
try {
System.IntPtr hwnd;
iVsUIShell.GetDialogOwnerHwnd(out hwnd);
try {
var className = replacements["$safeprojectname$"];
className = Regex.Replace(className, @"[^a-zA-Z0-9_]", string.Empty);
className = Regex.Replace(className, @"^[\d-]*\s*", string.Empty);
var result = new ClassNameValidationRule().Validate(className, null);
if (result != ValidationResult.ValidResult)
{
className = @"QtGuiApplication";
}
data.ClassName = className;
data.BaseClass = @"QMainWindow";
data.ClassHeaderFile = className + @".h";
data.ClassSourceFile = className + @".cpp";
data.UiFile = data.ClassName + @".ui";
data.QrcFile = data.ClassName + @".qrc";
var wizard = new WizardWindow(new List <WizardPage> {
new IntroPage {
Data = data,
Header = @"Welcome to the Qt GUI Application Wizard",
Message = @"This wizard generates a Qt GUI application project. The "
+ @"application derives from QApplication and includes an empty "
+ @"widget." + System.Environment.NewLine
+ System.Environment.NewLine + "To continue, click Next.",
PreviousButtonEnabled = false,
NextButtonEnabled = true,
FinishButtonEnabled = false,
CancelButtonEnabled = true
},
new ModulePage {
Data = data,
Header = @"Welcome to the Qt GUI Application Wizard",
Message = @"Select the modules you want to include in your project. The "
+ @"recommended modules for this project are selected by default.",
PreviousButtonEnabled = true,
NextButtonEnabled = true,
FinishButtonEnabled = false,
CancelButtonEnabled = true
},
new GuiPage {
Data = data,
Header = @"Welcome to the Qt GUI Application Wizard",
Message = @"This wizard generates a Qt GUI application project. The "
+ @"application derives from QApplication and includes an empty "
+ @"widget.",
PreviousButtonEnabled = true,
NextButtonEnabled = false,
FinishButtonEnabled = data.DefaultModules.All(QtModuleInfo.IsInstalled),
CancelButtonEnabled = true
}
})
{
Title = @"Qt GUI Application Wizard"
};
WindowHelper.ShowModal(wizard, hwnd);
if (!wizard.DialogResult.HasValue || !wizard.DialogResult.Value)
{
throw new System.Exception("Unexpected wizard return value.");
}
} catch (QtVSException exception) {
Messages.DisplayErrorMessage(exception.Message);
throw; // re-throw, but keep the original exception stack intact
}
var version = (automation as DTE).Version;
replacements["$ToolsVersion$"] = version;
var vm = QtVersionManager.The();
var vi = VersionInformation.Get(vm.GetInstallPath(vm.GetDefaultVersion()));
replacements["$Platform$"] = vi.GetVSPlatformName();
replacements["$Keyword$"] = Resources.qtProjectKeyword;
replacements["$ProjectGuid$"] = @"{B12702AD-ABFB-343A-A199-8E24837244A3}";
replacements["$PlatformToolset$"] = BuildConfig.PlatformToolset(version);
replacements["$classname$"] = data.ClassName;
replacements["$baseclass$"] = data.BaseClass;
replacements["$sourcefilename$"] = data.ClassSourceFile;
replacements["$headerfilename$"] = data.ClassHeaderFile;
replacements["$uifilename$"] = data.UiFile;
replacements["$precompiledheader$"] = string.Empty;
replacements["$precompiledsource$"] = string.Empty;
replacements["$DefaultApplicationIcon$"] = string.Empty;
replacements["$centralwidget$"] = string.Empty;
var strHeaderInclude = data.ClassHeaderFile;
if (data.UsePrecompiledHeader)
{
strHeaderInclude = "stdafx.h\"\r\n#include \"" + data.ClassHeaderFile;
replacements["$precompiledheader$"] = "<None Include=\"stdafx.h\" />";
replacements["$precompiledsource$"] = "<None Include=\"stdafx.cpp\" />";
}
replacements["$include$"] = strHeaderInclude;
replacements["$ui_hdr$"] = "ui_" + Path.GetFileNameWithoutExtension(data.UiFile)
+ ".h";
replacements["$qrcfilename$"] = data.QrcFile;
if (data.BaseClass == "QMainWindow")
{
replacements["$centralwidget$"] =
"\r\n <widget class=\"QMenuBar\" name=\"menuBar\" />"
+ "\r\n <widget class=\"QToolBar\" name=\"mainToolBar\" />"
+ "\r\n <widget class=\"QWidget\" name=\"centralWidget\" />"
+ "\r\n <widget class=\"QStatusBar\" name=\"statusBar\" />";
}
if (data.AddDefaultAppIcon)
{
replacements["$DefaultApplicationIcon$"] = "<None Include=\"gui.ico\" />";
}
if (vi.isWinRT())
{
replacements["$QtWinRT$"] = "true";
var projDir = replacements["$destinationdirectory$"];
var qmakeTmpDir = Path.Combine(projDir, "qmake_tmp");
Directory.CreateDirectory(qmakeTmpDir);
var dummyPro = Path.Combine(qmakeTmpDir,
string.Format("{0}.pro", replacements["$projectname$"]));
File.WriteAllText(dummyPro, "SOURCES = main.cpp\r\n");
var qmake = new QMake(null, dummyPro, false, vi);
qmake.RunQMake();
var assetsDir = Path.Combine(qmakeTmpDir, "assets");
if (Directory.Exists(assetsDir))
{
Directory.Move(assetsDir, Path.Combine(projDir, "assets"));
}
var manifestFile = Path.Combine(qmakeTmpDir, "Package.appxmanifest");
if (File.Exists(manifestFile))
{
File.Move(manifestFile, Path.Combine(projDir, "Package.appxmanifest"));
}
var projFile = Path.Combine(qmakeTmpDir,
string.Format("{0}.vcxproj", replacements["$projectname$"]));
var proj = MsBuildProject.Load(projFile);
replacements["$MinimumVisualStudioVersion$"] =
proj.GetProperty("MinimumVisualStudioVersion");
replacements["$ApplicationTypeRevision$"] =
proj.GetProperty("ApplicationTypeRevision");
replacements["$WindowsTargetPlatformVersion$"] =
proj.GetProperty("WindowsTargetPlatformVersion");
replacements["$isSet_WindowsTargetPlatformVersion$"] = "true";
replacements["$WindowsTargetPlatformMinVersion$"] =
proj.GetProperty("WindowsTargetPlatformMinVersion");
replacements["$Link_TargetMachine$"] =
proj.GetProperty("Link", "TargetMachine");
Directory.Delete(qmakeTmpDir, true);
}
#if (VS2017 || VS2015)
else
{
string versionWin10SDK = HelperFunctions.GetWindows10SDKVersion();
if (!string.IsNullOrEmpty(versionWin10SDK))
{
replacements["$WindowsTargetPlatformVersion$"] = versionWin10SDK;
replacements["$isSet_WindowsTargetPlatformVersion$"] = "true";
}
}
#endif
} catch {
try {
Directory.Delete(replacements["$destinationdirectory$"]);
Directory.Delete(replacements["$solutiondirectory$"]);
} catch { }
iVsUIShell.EnableModeless(1);
throw new WizardBackoutException();
}
iVsUIShell.EnableModeless(1);
}
protected virtual object GetReference(string name)
{
return(MsBuildProject.GetItems("Reference").FirstOrDefault(item => new AssemblyName(item.EvaluatedInclude).Name.Equals(name, StringComparison.OrdinalIgnoreCase)));
}
protected virtual void Save()
{
MsBuildProject.CommitChanges();
}