/// <summary> /// Changes all instances of a property in the <paramref name="project"/> by applying a method to its value. /// </summary> protected void FixProperty(MSBuildBasedProject project, string propertyName, Converter<string, string> method) { lock (project.SyncRoot) { foreach (MSBuild.BuildProperty p in project.GetAllProperties(propertyName)) { p.Value = method(p.Value); } } }
void CreateProject() { project = WebReferenceTestHelper.CreateTestProject("C#"); }
public static bool ProjectContainsExtension(MSBuildBasedProject msbuildProject) { return(msbuildProject.ContainsProjectExtension(ProjectExtensionName)); }
/// <summary> /// Default ctor /// </summary> public ProjectProperties(MSBuildBasedProject page) { this.project = page; }
void StartBuild() { Dictionary <string, string> globalProperties = new Dictionary <string, string>(); MSBuildBasedProject.InitializeMSBuildProjectProperties(globalProperties); foreach (KeyValuePair <string, string> pair in options.Properties) { LoggingService.Debug("Setting property " + pair.Key + " to '" + pair.Value + "'"); globalProperties[pair.Key] = pair.Value; } globalProperties["Configuration"] = options.Configuration; if (options.Platform == "Any CPU") { globalProperties["Platform"] = "AnyCPU"; } else { globalProperties["Platform"] = options.Platform; } InterestingTasks.AddRange(MSBuildEngine.CompileTaskNames); loggers.Add(new SharpDevelopLogger(this)); if (options.BuildOutputVerbosity == BuildOutputVerbosity.Diagnostic) { this.ReportMessageEvents = true; this.ReportAllTaskFinishedEvents = true; this.ReportAllTaskStartedEvents = true; this.ReportTargetFinishedEvents = true; this.ReportTargetStartedEvents = true; this.ReportUnknownEvents = true; loggers.Add(new SDConsoleLogger(feedbackSink, LoggerVerbosity.Diagnostic)); globalProperties["MSBuildTargetsVerbose"] = "true"; } //loggers.Add(new BuildLogFileLogger(project.FileName + ".log", LoggerVerbosity.Diagnostic)); foreach (IMSBuildAdditionalLogger loggerProvider in MSBuildEngine.AdditionalMSBuildLoggers) { loggers.Add(loggerProvider.CreateLogger(this)); } loggerChain = new EndOfChain(this); foreach (IMSBuildLoggerFilter loggerFilter in MSBuildEngine.MSBuildLoggerFilters) { loggerChain = loggerFilter.CreateFilter(this, loggerChain) ?? loggerChain; } WriteAdditionalTargetsToTempFile(globalProperties); BuildJob job = new BuildJob(); job.ProjectFileName = projectFileName; job.Target = options.Target.TargetName; // First remove the flags for the controllable events. job.EventMask = EventTypes.All & ~ControllableEvents; // Add back active controllable events. if (ReportMessageEvents) { job.EventMask |= EventTypes.Message; } if (ReportTargetStartedEvents) { job.EventMask |= EventTypes.TargetStarted; } if (ReportTargetFinishedEvents) { job.EventMask |= EventTypes.TargetFinished; } if (ReportAllTaskStartedEvents) { job.EventMask |= EventTypes.TaskStarted; } if (ReportAllTaskFinishedEvents) { job.EventMask |= EventTypes.TaskFinished; } if (ReportUnknownEvents) { job.EventMask |= EventTypes.Unknown; } if (!(ReportAllTaskStartedEvents && ReportAllTaskFinishedEvents)) { // just some TaskStarted & TaskFinished events should be reported job.InterestingTaskNames.AddRange(InterestingTasks); } foreach (var pair in globalProperties) { job.Properties.Add(pair.Key, pair.Value); } foreach (ILogger logger in loggers) { logger.Initialize(eventSource); } if (projectMinimumSolutionVersion <= Solution.SolutionVersionVS2008) { BuildWorkerManager.MSBuild35.RunBuildJob(job, loggerChain, OnDone, feedbackSink.ProgressMonitor.CancellationToken); } else { BuildWorkerManager.MSBuild40.RunBuildJob(job, loggerChain, OnDone, feedbackSink.ProgressMonitor.CancellationToken); } }
//Show prompt, create files from template, create project, execute command, save project public bool CreateProject(ProjectTemplateResult templateResults, string defaultLanguage, ISolutionFolder target) { var projectCreateOptions = templateResults.Options; var parentSolution = templateResults.Options.Solution; IProject project = null; bool success = false; try { string language = string.IsNullOrEmpty(languageName) ? defaultLanguage : languageName; ProjectBindingDescriptor descriptor = SD.ProjectService.ProjectBindings.FirstOrDefault(b => b.Language == language); IProjectBinding languageinfo = (descriptor != null) ? descriptor.Binding : null; if (languageinfo == null) { MessageService.ShowError( StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.CantCreateProjectWithTypeError}", new StringTagPair("type", language))); return(false); } DirectoryName projectBasePath = GetProjectBasePath(projectCreateOptions); string newProjectName = StringParser.Parse(name, new StringTagPair("ProjectName", projectCreateOptions.ProjectName)); Directory.CreateDirectory(projectBasePath); FileName projectLocation = projectBasePath.CombineFile(newProjectName + descriptor.ProjectFileExtension); ProjectCreateInformation info = new ProjectCreateInformation(parentSolution, projectLocation); info.TargetFramework = projectCreateOptions.TargetFramework; StringBuilder standardNamespace = new StringBuilder(); // filter 'illegal' chars from standard namespace if (!string.IsNullOrEmpty(newProjectName)) { char ch = '.'; for (int i = 0; i < newProjectName.Length; ++i) { if (ch == '.') { // at beginning or after '.', only a letter or '_' is allowed ch = newProjectName[i]; if (!Char.IsLetter(ch)) { standardNamespace.Append('_'); } else { standardNamespace.Append(ch); } } else { ch = newProjectName[i]; // can only contain letters, digits or '_' if (!Char.IsLetterOrDigit(ch) && ch != '.') { standardNamespace.Append('_'); } else { standardNamespace.Append(ch); } } } } info.TypeGuid = descriptor.TypeGuid; info.RootNamespace = standardNamespace.ToString(); info.ProjectName = newProjectName; if (!string.IsNullOrEmpty(defaultPlatform)) { info.ActiveProjectConfiguration = new ConfigurationAndPlatform("Debug", defaultPlatform); } RunPreCreateActions(info); StringParserPropertyContainer.FileCreation["StandardNamespace"] = info.RootNamespace; if (File.Exists(projectLocation)) { if (!MessageService.AskQuestion( StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteProjectQuestion}", new StringTagPair("projectLocation", projectLocation)), "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}")) { return(false); //The user doesnt want to overwrite the project... } } //Show prompt if any of the files exist StringBuilder existingFileNames = new StringBuilder(); foreach (FileDescriptionTemplate file in files) { string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", info.ProjectName))); if (File.Exists(fileName)) { if (existingFileNames.Length > 0) { existingFileNames.Append(", "); } existingFileNames.Append(Path.GetFileName(fileName)); } } bool overwriteFiles = true; if (existingFileNames.Length > 0) { if (!MessageService.AskQuestion( StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion}", new StringTagPair("fileNames", existingFileNames.ToString())), "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}")) { overwriteFiles = false; } } #region Copy files to target directory foreach (FileDescriptionTemplate file in files) { string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", info.ProjectName))); if (File.Exists(fileName) && !overwriteFiles) { continue; } try { if (!Directory.Exists(Path.GetDirectoryName(fileName))) { Directory.CreateDirectory(Path.GetDirectoryName(fileName)); } if (!String.IsNullOrEmpty(file.BinaryFileName)) { // Binary content File.Copy(file.BinaryFileName, fileName, true); } else { // Textual content StreamWriter sr = new StreamWriter(File.Create(fileName), SD.FileService.DefaultFileEncoding); string fileContent = StringParser.Parse(file.Content, new StringTagPair("ProjectName", projectCreateOptions.ProjectName), new StringTagPair("SolutionName", projectCreateOptions.SolutionName), new StringTagPair("FileName", fileName)); fileContent = StringParser.Parse(fileContent); if (SD.EditorControlService.GlobalOptions.IndentationString != "\t") { fileContent = fileContent.Replace("\t", SD.EditorControlService.GlobalOptions.IndentationString); } sr.Write(fileContent); sr.Close(); } } catch (Exception ex) { MessageService.ShowException(ex, "Exception writing " + fileName); } } #endregion // Create Project info.InitializeTypeSystem = false; project = languageinfo.CreateProject(info); #region Create Project Items, Imports and Files // Add Project items if (!project.Items.IsReadOnly) { foreach (ProjectItem projectItem in projectItems) { ProjectItem newProjectItem = new UnknownProjectItem( project, StringParser.Parse(projectItem.ItemType.ItemName), StringParser.Parse(projectItem.Include, new StringTagPair("ProjectName", projectCreateOptions.ProjectName), new StringTagPair("SolutionName", projectCreateOptions.SolutionName)) ); foreach (string metadataName in projectItem.MetadataNames) { string metadataValue = projectItem.GetMetadata(metadataName); // if the input contains any special MSBuild sequences, don't escape the value // we want to escape only when the special characters are introduced by the StringParser.Parse replacement if (metadataValue.Contains("$(") || metadataValue.Contains("%")) { newProjectItem.SetMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue)); } else { newProjectItem.SetEvaluatedMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue)); } } project.Items.Add(newProjectItem); } } // Add properties from <PropertyGroup> // This must be done before adding <Imports>, because the import path can refer to properties. if (projectProperties.Count > 0) { if (!(project is MSBuildBasedProject)) { throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects"); } foreach (ProjectProperty p in projectProperties) { ((MSBuildBasedProject)project).SetProperty( StringParser.Parse(p.Configuration), StringParser.Parse(p.Platform), StringParser.Parse(p.Name), StringParser.Parse(p.Value), p.Location, p.ValueIsLiteral ); } } // Add Imports if (clearExistingImports || projectImports.Count > 0) { MSBuildBasedProject msbuildProject = project as MSBuildBasedProject; if (msbuildProject == null) { throw new Exception("<Imports> may be only used in project templates for MSBuildBasedProjects"); } try { msbuildProject.PerformUpdateOnProjectFile( delegate { var projectFile = msbuildProject.MSBuildProjectFile; if (clearExistingImports) { foreach (var import in projectFile.Imports.ToArray()) { projectFile.RemoveChild(import); } } foreach (Import projectImport in projectImports) { projectFile.AddImport(projectImport.Key).Condition = projectImport.Value; } }); } catch (InvalidProjectFileException ex) { string message; if (string.IsNullOrEmpty(importsFailureMessage)) { message = "Error creating project:\n" + ex.Message; } else { message = importsFailureMessage + "\n\n" + ex.Message; } throw new ProjectLoadException(message, ex); } } // Add Files if (!project.Items.IsReadOnly) { foreach (FileDescriptionTemplate file in files) { string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", projectCreateOptions.ProjectName))); FileProjectItem projectFile = new FileProjectItem(project, project.GetDefaultItemType(fileName)); projectFile.Include = FileUtility.GetRelativePath(project.Directory, fileName); file.SetProjectItemProperties(projectFile); project.Items.Add(projectFile); } } #endregion RunCreateActions(project); project.ProjectCreationComplete(); // Save project project.Save(); // HACK : close and reload var fn = project.FileName; project.Dispose(); ProjectLoadInformation loadInfo = new ProjectLoadInformation(parentSolution, fn, fn.GetFileNameWithoutExtension()); project = SD.ProjectService.LoadProject(loadInfo); target.Items.Add(project); project.ProjectLoaded(); SD.GetRequiredService <IProjectServiceRaiseEvents>().RaiseProjectCreated(new ProjectEventArgs(project)); templateResults.NewProjects.Add(project); success = true; return(true); } finally { if (project != null && !success) { project.Dispose(); } } }
public IPackageManagementProject GetProject(IPackageRepository sourceRepository, string projectName) { MSBuildBasedProject msbuildProject = GetMSBuildProject(projectName); return(CreateProject(sourceRepository, msbuildProject)); }
public IPackageManagementProject GetProject(PackageSource source, string projectName) { MSBuildBasedProject msbuildProject = GetMSBuildProject(projectName); return(CreateProject(source, msbuildProject)); }
public static FileProjectItem GetFile(MSBuildBasedProject project, string fileName) { return(project.FindFile(FileName.Create(fileName))); }
public IProjectSystem CreateProjectSystem(MSBuildBasedProject project) { return(new SharpDevelopProjectSystem(project)); }
void CreateProjectSystem(MSBuildBasedProject project) { projectSystem = new TestableSharpDevelopProjectSystem(project); }
public ISharpDevelopPackageManager CreatePackageManager(IPackageRepository sourceRepository, MSBuildBasedProject project) { PackageRepositoryPassedToCreatePackageManager = sourceRepository; ProjectPassedToCreateRepository = project; return(FakePackageManager); }
public MSBuildProjectPropertiesMerger(Project msbuildProject, MSBuildBasedProject sharpDevelopProject) : this(msbuildProject, sharpDevelopProject, new PackageManagementProjectService()) { }
internal ProjectItem(MSBuildBasedProject project, IClass c) : this(new Project(project), project.FindFile(c.CompilationUnit.FileName)) { }
void StartBuild() { WorkerManager.ShowError = MessageService.ShowError; BuildWorker.BuildSettings settings = new BuildWorker.BuildSettings(); SharpDevelopLogger logger = new SharpDevelopLogger(this); settings.Logger.Add(logger); InterestingTasks.AddRange(MSBuildEngine.CompileTaskNames); foreach (IMSBuildAdditionalLogger loggerProvider in MSBuildEngine.AdditionalMSBuildLoggers) { settings.Logger.Add(loggerProvider.CreateLogger(this)); } BuildJob job = new BuildJob(); job.IntPtrSize = IntPtr.Size; job.ProjectFileName = project.FileName; // Never report custom events (those are usually derived EventArgs classes, and SharpDevelop // doesn't have the matching assemblies loaded - see SD2-1514). // Also, remove the flags for the controllable events. job.EventMask = EventTypes.All & ~(ControllableEvents | EventTypes.Custom); // Add back active controllable events. if (ReportMessageEvents) { job.EventMask |= EventTypes.Message; } if (ReportTargetStartedEvents) { job.EventMask |= EventTypes.TargetStarted; } if (ReportTargetFinishedEvents) { job.EventMask |= EventTypes.TargetFinished; } if (ReportAllTaskStartedEvents) { job.EventMask |= EventTypes.TaskStarted; } if (ReportAllTaskFinishedEvents) { job.EventMask |= EventTypes.TaskFinished; } if (ReportUnknownEvents) { job.EventMask |= EventTypes.Unknown; } if (!(ReportAllTaskStartedEvents && ReportAllTaskFinishedEvents)) { // just some TaskStarted & TaskFinished events should be reported job.InterestingTaskNames.AddRange(InterestingTasks); } job.AdditionalImports.AddRange(additionalTargetFiles); BuildPropertyGroup pg = new BuildPropertyGroup(); MSBuildBasedProject.InitializeMSBuildProjectProperties(pg); foreach (BuildProperty p in pg) { job.Properties[p.Name] = p.FinalValue; } Solution solution = project.ParentSolution; job.Properties["SolutionDir"] = EnsureBackslash(solution.Directory); job.Properties["SolutionExt"] = ".sln"; job.Properties["SolutionFileName"] = Path.GetFileName(solution.FileName); job.Properties["SolutionPath"] = solution.FileName; foreach (var pair in options.Properties) { job.Properties[pair.Key] = pair.Value; } job.Properties["Configuration"] = options.Configuration; if (options.Platform == "Any CPU") { job.Properties["Platform"] = "AnyCPU"; } else { job.Properties["Platform"] = options.Platform; } job.Target = options.Target.TargetName; bool buildInProcess = false; if (AllowBuildInProcess && Interlocked.CompareExchange(ref isBuildingInProcess, 1, 0) == 0) { buildInProcess = true; } //HACK: Build .net 4.0 projects in process if (SDLite.BuildHelper.IsProject40(File.ReadAllText(project.FileName))) { buildInProcess = true; Interlocked.Exchange(ref isBuildingInProcess, 1); } LoggingService.Info("Start job (buildInProcess=" + buildInProcess + "): " + job.ToString()); if (buildInProcess) { settings.BuildDoneCallback = delegate(bool success) { LoggingService.Debug("BuildInProcess: Received BuildDoneCallback"); if (Interlocked.Exchange(ref isBuildingInProcess, 0) != 1) { //HACK: It takes no sense. //MessageService.ShowError("isBuildingInProcess should have been 1!"); } logger.FlushCurrentError(); feedbackSink.Done(success); }; Thread thread = new Thread(new ThreadStart( delegate { LoggingService.Debug("Acquiring InProcessMSBuildLock"); lock (MSBuildInternals.InProcessMSBuildLock) { WorkerManager.RunBuildInProcess(job, settings); LoggingService.Debug("Leaving InProcessMSBuildLock"); } })); thread.Name = "InProcess build thread " + thread.ManagedThreadId; thread.SetApartmentState(ApartmentState.STA); thread.Start(); } else { settings.BuildDoneCallback = delegate(bool success) { LoggingService.Debug("BuildOutOfProcess: Received BuildDoneCallback"); logger.FlushCurrentError(); feedbackSink.Done(success); }; WorkerManager.StartBuild(job, settings); } }
protected override bool Save(MSBuildBasedProject project, string configuration, string platform) { this.CodeAnalysisRules.Value = RuleString; return(base.Save(project, configuration, platform)); }
IPackageManagementProject CreateProject(IPackageRepository sourceRepository, MSBuildBasedProject project) { return(projectFactory.CreateProject(sourceRepository, project)); }
public static void AddWebApplicationProjectType(MSBuildBasedProject project) { AddProjectType(project, ProjectTypeGuids.WebApplication); }
IPackageManagementProject CreateProject(PackageSource source, MSBuildBasedProject project) { IPackageRepository sourceRepository = CreatePackageRepository(source); return(CreateProject(sourceRepository, project)); }
public static void AddProjectType(MSBuildBasedProject project, Guid guid) { project.AddProjectType(guid); }
void PerformConversion(string translatedTitle, MSBuildBasedProject sourceProject, string targetProjectDirectory) { IProject targetProject; using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog(translatedTitle, "Converting", true)) { Directory.CreateDirectory(targetProjectDirectory); targetProject = CreateProject(targetProjectDirectory, sourceProject); CopyProperties(sourceProject, targetProject); conversionLog.AppendLine(); CopyItems(sourceProject, targetProject, monitor); monitor.CancellationToken.ThrowIfCancellationRequested(); conversionLog.AppendLine(); AfterConversion(targetProject); conversionLog.AppendLine(ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.ConversionComplete")); targetProject.Save(); targetProject.Dispose(); } TreeNode node = ProjectBrowserPad.Instance.SelectedNode; if (node == null) { node = ProjectBrowserPad.Instance.SolutionNode; } while (node != null) { if (node is ISolutionFolderNode) { AddExistingProjectToSolution.AddProject((ISolutionFolderNode)node, targetProject.FileName); ProjectService.SaveSolution(); break; } node = node.Parent; } IViewContent newFileWindow; newFileWindow = FileService.NewFile(ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.ConversionResults"), conversionLog.ToString()); if (newFileWindow != null) { newFileWindow.PrimaryFile.IsDirty = false; } }
/// <summary> /// Resolves the location of the reference files. /// </summary> /// <param name="baseProject">The base project.</param> /// <param name="referenceReplacements">A different set of references to use instead of those in the project. /// Used by the GacReferencePanel.</param> internal static void ResolveAssemblyReferences(MSBuildBasedProject baseProject, ReferenceProjectItem[] referenceReplacements) { ProjectInstance project = baseProject.CreateProjectInstance(); project.SetProperty("BuildingProject", "false"); List <ProjectItemInstance> references = ( from item in project.Items where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType)) select item ).ToList(); ReferenceProjectItem[] referenceProjectItems; if (referenceReplacements == null) { // Remove the "Private" meta data. // This is necessary to detect the default value for "Private" foreach (ProjectItemInstance reference in references) { reference.RemoveMetadata("Private"); } referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToArray(); } else { foreach (ProjectItemInstance reference in references) { project.RemoveItem(reference); } foreach (ReferenceProjectItem item in referenceReplacements) { project.AddItem("Reference", item.Include); } referenceProjectItems = referenceReplacements; } string[] targets = { "ResolveAssemblyReferences" }; BuildRequestData requestData = new BuildRequestData(project, targets, new HostServices()); List <ILogger> loggers = new List <ILogger>(); if (referenceReplacements == null) { loggers.Add(new SimpleErrorLogger()); } lock (SolutionProjectCollectionLock) { BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection); parameters.Loggers = loggers; LoggingService.Debug("Started build for ResolveAssemblyReferences"); BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData); if (result == null) { throw new InvalidOperationException("BuildResult is null"); } LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult); } var referenceDict = new Dictionary <string, ReferenceProjectItem>(); foreach (ReferenceProjectItem item in referenceProjectItems) { // references could be duplicate, so we cannot use referenceDict.Add or reference.ToDictionary referenceDict[item.Include] = item; } foreach (ProjectItemInstance item in project.GetItems("_ResolveAssemblyReferenceResolvedFiles")) { string originalInclude = item.GetMetadataValue("OriginalItemSpec"); ReferenceProjectItem reference; if (referenceDict.TryGetValue(originalInclude, out reference)) { reference.AssemblyName = new Dom.DomAssemblyName(item.GetMetadataValue("FusionName")); //string fullPath = item.GetEvaluatedMetadata("FullPath"); is incorrect for relative paths string fullPath = FileUtility.GetAbsolutePath(baseProject.Directory, item.GetMetadataValue("Identity")); reference.FileName = fullPath; reference.Redist = item.GetMetadataValue("Redist"); LoggingService.Debug("Got information about " + originalInclude + "; fullpath=" + fullPath); reference.DefaultCopyLocalValue = bool.Parse(item.GetMetadataValue("CopyLocal")); } else { LoggingService.Warn("Unknown item " + originalInclude); } } }
/// <summary> /// Resolves the location of the reference files. /// </summary> /// <param name="baseProject">The base project.</param> /// <param name="referenceReplacements">A different set of references to use instead of those in the project. /// Used by the GacReferencePanel.</param> public static IList <ReferenceProjectItem> ResolveAssemblyReferences( MSBuildBasedProject baseProject, ReferenceProjectItem[] additionalReferences = null, bool resolveOnlyAdditionalReferences = false, bool logErrorsToOutputPad = true) { ProjectInstance project = baseProject.CreateProjectInstance(); project.SetProperty("BuildingProject", "false"); project.SetProperty("DesignTimeBuild", "true"); List <ProjectItemInstance> references = ( from item in project.Items where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType)) select item ).ToList(); List <ReferenceProjectItem> referenceProjectItems; if (resolveOnlyAdditionalReferences) { // Remove existing references from project foreach (ProjectItemInstance reference in references) { project.RemoveItem(reference); } references.Clear(); referenceProjectItems = new List <ReferenceProjectItem>(); } else { // Remove the "Private" meta data. // This is necessary to detect the default value for "Private" foreach (ProjectItemInstance reference in references) { reference.RemoveMetadata("Private"); } referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToList(); } if (additionalReferences != null) { referenceProjectItems.AddRange(additionalReferences); foreach (ReferenceProjectItem item in additionalReferences) { references.Add(project.AddItem("Reference", item.Include)); } } List <string> targets = new List <string>(); if (baseProject.HasProjectType(ProjectTypeGuids.PortableLibrary)) { targets.Add("ResolveReferences"); targets.Add("DesignTimeResolveAssemblyReferences"); } else { targets.Add("ResolveAssemblyReferences"); } BuildRequestData requestData = new BuildRequestData(project, targets.ToArray(), new HostServices()); List <ILogger> loggers = new List <ILogger>(); //loggers.Add(new ConsoleLogger(LoggerVerbosity.Diagnostic)); if (logErrorsToOutputPad) { loggers.Add(new SimpleErrorLogger()); } lock (SolutionProjectCollectionLock) { BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection); parameters.Loggers = loggers; LoggingService.Debug("Started build for ResolveAssemblyReferences"); BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData); if (result == null) { throw new InvalidOperationException("BuildResult is null"); } LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult); } IEnumerable <ProjectItemInstance> resolvedAssemblyProjectItems = project.GetItems("_ResolveAssemblyReferenceResolvedFiles"); var query = from msbuildItem in resolvedAssemblyProjectItems where msbuildItem.GetMetadataValue("ReferenceSourceTarget") != "ProjectReference" let originalInclude = msbuildItem.GetMetadataValue("OriginalItemSpec") join item in referenceProjectItems.Where(p => p.ItemType != ItemType.ProjectReference) on originalInclude equals item.Include into referenceItems select new { OriginalInclude = originalInclude, AssemblyName = new DomAssemblyName(msbuildItem.GetMetadataValue("FusionName")), FullPath = FileUtility.GetAbsolutePath(baseProject.Directory, msbuildItem.GetMetadataValue("Identity")), Redist = msbuildItem.GetMetadataValue("Redist"), CopyLocal = bool.Parse(msbuildItem.GetMetadataValue("CopyLocal")), ReferenceItems = referenceItems }; // HACK: mscorlib is reported twice for portable library projects (even if we don't specify it as additionalReference) query = query.DistinctBy(asm => asm.FullPath); List <ReferenceProjectItem> resolvedAssemblies = new List <ReferenceProjectItem>(); List <ReferenceProjectItem> handledReferenceItems = new List <ReferenceProjectItem>(); foreach (var assembly in query) { LoggingService.Debug("Got information about " + assembly.OriginalInclude + "; fullpath=" + assembly.FullPath); foreach (var referenceItem in assembly.ReferenceItems) { referenceItem.AssemblyName = assembly.AssemblyName; referenceItem.FileName = assembly.FullPath; referenceItem.Redist = assembly.Redist; referenceItem.DefaultCopyLocalValue = assembly.CopyLocal; handledReferenceItems.Add(referenceItem); } ReferenceProjectItem firstItem = assembly.ReferenceItems.FirstOrDefault(); if (firstItem != null) { resolvedAssemblies.Add(firstItem); } else { resolvedAssemblies.Add(new ReferenceProjectItem(baseProject, assembly.OriginalInclude) { FileName = assembly.FullPath }); } } // Add any assemblies that weren't resolved yet. This is important - for example, this adds back project references. foreach (var referenceItem in referenceProjectItems.Except(handledReferenceItems)) { resolvedAssemblies.Add(referenceItem); } return(resolvedAssemblies); }
public override void Run() { conversionLog = new StringBuilder(); string translatedTitle = ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.ProjectConverter"); conversionLog.AppendLine(translatedTitle); conversionLog.Append('=', translatedTitle.Length); conversionLog.AppendLine(); conversionLog.AppendLine(); MSBuildBasedProject sourceProject = ProjectService.CurrentProject as MSBuildBasedProject; string targetProjectDirectory = sourceProject.Directory + ".ConvertedTo" + TargetLanguageName; if (Directory.Exists(targetProjectDirectory)) { MessageService.ShowMessageFormatted(translatedTitle, "${res:ICSharpCode.SharpDevelop.Commands.Convert.TargetAlreadyExists}", targetProjectDirectory); return; } conversionLog.Append(ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.SourceDirectory")).Append(": "); conversionLog.AppendLine(sourceProject.Directory); conversionLog.Append(ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.TargetDirectory")).Append(": "); conversionLog.AppendLine(targetProjectDirectory); IProject targetProject; using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog(translatedTitle)) { Directory.CreateDirectory(targetProjectDirectory); targetProject = CreateProject(targetProjectDirectory, sourceProject); CopyProperties(sourceProject, targetProject); conversionLog.AppendLine(); CopyItems(sourceProject, targetProject, monitor); if (monitor.IsCancelled) { return; } conversionLog.AppendLine(); AfterConversion(targetProject); conversionLog.AppendLine(ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.ConversionComplete")); targetProject.Save(); targetProject.Dispose(); } TreeNode node = ProjectBrowserPad.Instance.SelectedNode; if (node == null) { node = ProjectBrowserPad.Instance.SolutionNode; } while (node != null) { if (node is ISolutionFolderNode) { AddExitingProjectToSolution.AddProject((ISolutionFolderNode)node, targetProject.FileName); ProjectService.SaveSolution(); break; } node = node.Parent; } IViewContent newFileWindow; newFileWindow = FileService.NewFile(ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.Convert.ConversionResults"), conversionLog.ToString()); if (newFileWindow != null) { newFileWindow.PrimaryFile.IsDirty = false; } }
void CreateWebProject(MSBuildBasedProject project) { webProject = new WebProject(project); properties = webProject.GetWebProjectProperties(); }
protected void InitializeHelper() { project = (MSBuildBasedProject)((Properties)CustomizationObject).Get("Project"); baseDirectory = project.Directory; helper = new ConfigurationGuiHelper(project, this.ControlDictionary); }
public VisualStudioProjectExtension(MSBuildBasedProject msbuildProject) { this.msbuildProject = msbuildProject; }
public WebProject(MSBuildBasedProject msbuildProject) { this.msbuildProject = msbuildProject; }
public void Save(MSBuildBasedProject msbuildProject) { msbuildProject.SaveProjectExtensions(ProjectExtensionName, ToXElement()); }
private static void SpecifyRuntimeLibrary(MSBuildBasedProject project, string configuration, string runtime) { MSBuildItemDefinitionGroup group = new MSBuildItemDefinitionGroup(project, configuration, null); group.SetElementMetadata("ClCompile", "RuntimeLibrary", runtime); }
public static void AddReference(MSBuildBasedProject project, string referenceName) { var referenceProjectItem = new ReferenceProjectItem(project, referenceName); ProjectService.AddProjectItem(project, referenceProjectItem); }
public FakeFileService(MSBuildBasedProject project) { this.project = project; }