/// <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;
}
