static void CheckConfigurationMappings(DotNetProject project, string currentConfig)
{
var projConfig = (DotNetProjectConfiguration)project.GetConfiguration (IdeApp.Workspace.ActiveConfiguration);
if (project.GetConfigurations ().Contains (currentConfig) && projConfig.Name != currentConfig)
LogIssue (project, "configuration", currentConfig, projConfig.Name);
if (currentConfig.IndexOf ("Debug", StringComparison.OrdinalIgnoreCase) != -1)
return;
// Fixup entries for release configs.
var debugEntry = project.ParentSolution
.GetConfiguration (new SolutionConfigurationSelector (currentConfig.Replace ("Release", "Debug")))
.GetEntryForItem (project);
if (debugEntry == null)
return;
IdeApp.Workspace.ActiveConfigurationId = currentConfig;
var entry = project.ParentSolution.GetConfiguration (IdeApp.Workspace.ActiveConfiguration).GetEntryForItem (project);
entry.Build = debugEntry.Build;
entry.Deploy = debugEntry.Deploy;
var newConfig = debugEntry.ItemConfiguration.Replace ("Debug", "Release");
if (project.GetConfigurations ().Any (config => config == newConfig))
entry.ItemConfiguration = newConfig;
else {
LogIssue (project, "configuration", newConfig, "Missing");
entry.ItemConfiguration = debugEntry.ItemConfiguration;
}
}
public NSObjectProjectInfo GetProjectInfo (DotNetProject project, IAssembly lookinAssembly = null)
{
var dom = TypeSystemService.GetProjectContentWrapper (project);
project.ReferenceAddedToProject += HandleDomReferencesUpdated;
project.ReferenceRemovedFromProject += HandleDomReferencesUpdated;
return GetProjectInfo (dom, lookinAssembly);
}
public void Load (DotNetProject project, DotNetProjectConfiguration configuration)
{
this.project = project;
this.configuration = configuration;
compileTargetCombo.Active = configuration.CompileTarget == CompileTarget.Exe ? 0 : 1;
checkbuttonIncludeDebugInfo.Active = configuration.DebugSymbols;
}
public void LoadConfigData (ProjectConfigurationPropertyPanel dlg)
{
configuration = (DotNetProjectConfiguration) dlg.CurrentConfiguration;
project = (DotNetProject) dlg.ConfiguredProject;
compilerParameters = (JavaCompilerParameters) configuration.CompilationParameters;
compileTargetCombo.Active = (int) configuration.CompileTarget;
if (compilerParameters.Compiler == JavaCompiler.Javac)
compilerJavacButton.Active = true;
else
compilerGcjButton.Active = true;
enableOptimizationCheckButton.Active = compilerParameters.Optimize;
generateDebugInformationCheckButton.Active = configuration.DebugMode;
deprecationCheckButton.Active = compilerParameters.Deprecation;
generateWarningsCheckButton.Active = compilerParameters.GenWarnings;
warningsAsErrorsCheckButton.Active = !configuration.RunWithWarnings;
compilerEntry.Text = compilerParameters.CompilerPath;
classPathEntry.Text = compilerParameters.ClassPath;
mainClassEntry.Text = compilerParameters.MainClass;
symbolsEntry.Text = compilerParameters.DefineSymbols;
OnCompilerToggled (null, null);
}
public static IEnumerable<WebReferenceItem> GetWebReferenceItems (DotNetProject project)
{
foreach (WebReferenceItem item in WcfEngine.GetReferenceItems (project))
yield return item;
foreach (WebReferenceItem item in WsEngine.GetReferenceItems (project))
yield return item;
}
public static NUnitProjectTestSuite CreateTest (DotNetProject project)
{
foreach (ProjectReference p in project.References)
if (p.Reference.IndexOf ("nunit.framework") != -1 || p.Reference.IndexOf ("nunit.core") != -1)
return new NUnitProjectTestSuite (project);
return null;
}
public AddControllerDialog (DotNetProject project)
{
Build ();
var ext = project.GetService<AspNetAppProjectFlavor> ();
provider = project.LanguageBinding.GetCodeDomProvider ();
loadedTemplateList = ext.GetCodeTemplates ("AddController");
bool foundEmptyTemplate = false;
int templateIndex = 0;
foreach (string file in loadedTemplateList) {
string name = System.IO.Path.GetFileNameWithoutExtension (file);
templateCombo.AppendText (name);
if (!foundEmptyTemplate) {
if (name == "Empty") {
templateCombo.Active = templateIndex;
foundEmptyTemplate = true;
} else
templateIndex++;
}
}
if (!foundEmptyTemplate)
throw new Exception ("The Empty.tt template is missing.");
nameEntry.Text = "Controller";
nameEntry.Position = 0;
Validate ();
}
public References(
MD.DotNetProject project,
IExtendedPackageManagementProjectService projectService)
{
this.msbuildProject = project;
this.projectService = projectService;
}
public static NUnitProjectTestSuite CreateTest (DotNetProject project)
{
foreach (var p in project.References)
if (p.Reference.IndexOf ("GuiUnit", StringComparison.OrdinalIgnoreCase) != -1 || p.Reference.IndexOf ("nunit.framework") != -1 || p.Reference.IndexOf ("nunit.core") != -1)
return new NUnitProjectTestSuite (project);
return null;
}
public RuntimeOptionsPanelWidget (DotNetProject project, IEnumerable<ItemConfiguration> configurations)
{
Build ();
this.project = project;
if (project != null) {
// Get the list of available versions, and add only those supported by the target language.
foreach (TargetFramework fx in Runtime.SystemAssemblyService.GetTargetFrameworks ()) {
if (fx != project.TargetFramework) {
if (!project.TargetRuntime.IsInstalled (fx))
continue;
if (!project.SupportsFramework (fx))
continue;
}
runtimeVersionCombo.AppendText (fx.Name);
if (project.TargetFramework == fx)
runtimeVersionCombo.Active = supportedVersions.Count;
supportedVersions.Add (fx);
}
if (supportedVersions.Count <= 1)
Sensitive = false;
}
else
Sensitive = false;
}
public AddViewDialog (DotNetProject project)
{
this.project = project;
aspFlavor = project.GetService<AspNetAppProjectFlavor> ();
Build ();
provider = project.LanguageBinding.GetCodeDomProvider ();
var viewEngines = GetProperViewEngines ();
loadedTemplateList = new Dictionary<string, IList<string>> ();
foreach (var engine in viewEngines) {
viewEngineCombo.AppendText (engine);
loadedTemplateList[engine] = aspFlavor.GetCodeTemplates ("AddView", engine);
}
viewEngineCombo.Active = 0;
InitializeTemplateStore (loadedTemplateList);
ContentPlaceHolders = new List<string> ();
string siteMaster = aspFlavor.VirtualToLocalPath ("~/Views/Shared/Site.master", null);
if (project.Files.GetFile (siteMaster) != null)
masterEntry.Text = "~/Views/Shared/Site.master";
placeholderCombo.Model = primaryPlaceholderStore;
UpdateTypePanelSensitivity (null, null);
UpdateMasterPanelSensitivity (null, null);
Validate ();
}
static void OnProjectAdded(DotNetProject project)
{
QyotoDesignInfo info = (QyotoDesignInfo)project.ExtendedProperties["QyotoDesignInfo"];
if (info != null) {
info.Project = project;
}
}
void RefreshChildNodes (DotNetProject project)
{
ITreeBuilder builder = Context.GetTreeBuilder (project);
if (builder != null) {
builder.UpdateChildren ();
}
}
public static BuildResult UpdateDesignerFile (
CodeBehindWriter writer,
DotNetProject project,
ProjectFile file, ProjectFile designerFile
)
{
var result = new BuildResult ();
//parse the ASP.NET file
var parsedDocument = TypeSystemService.ParseFile (project, file.FilePath).Result as WebFormsParsedDocument;
if (parsedDocument == null) {
result.AddError (string.Format ("Failed to parse file '{0}'", file.Name));
return result;
}
//TODO: ensure type system is up to date
CodeCompileUnit ccu;
result.Append (GenerateCodeBehind (project, designerFile.FilePath, parsedDocument, out ccu));
if (ccu != null) {
writer.WriteFile (designerFile.FilePath, ccu);
}
return result;
}
public XcodeSyncBackContext (FilePath projectDir, Dictionary<string,DateTime> syncTimes,
NSObjectInfoService infoService, DotNetProject project)
: base (projectDir, syncTimes)
{
InfoService = infoService;
Project = project;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:MonoDevelop.ConnectedServices.ConnectedService"/> class.
/// </summary>
protected ConnectedService (DotNetProject project)
{
this.Project = project;
this.Dependencies = ConnectedServiceDependency.Empty;
this.Sections = ConfigurationSection.Empty;
this.DependenciesSection = new DependenciesSection (this);
}
public NodeEditorWidget (DotNetProject project, AddinRegistry reg, ExtensionNodeType ntype, AddinDescription parentAddinDescription, string parentPath, ExtensionNodeDescription node)
{
this.node = node;
this.project = project;
tips = new Tooltips ();
Spacing = 0;
// Header
Label label = new Label ();
label.Wrap = true;
label.WidthRequest = 480;
string txt = "<b>" + node.NodeName + "</b>";
if (ntype.Description.Length > 0)
txt += "\n" + GLib.Markup.EscapeText (ntype.Description);
label.Markup = txt;
label.Xalign = 0f;
PackStart (label, false, false, 6);
PackStart (new HSeparator (), false, false, 0);
// Attributes
grid = new PropertyGrid ();
grid.CurrentObject = new NodeWrapper (project, reg, ntype, parentAddinDescription, parentPath, node);
PackStart (grid, true, true, 0);
ShowAll ();
grid.ShowHelp = true;
grid.ShowToolbar = false;
}
public SelectNodeSetDialog (DotNetProject project, AddinRegistry registry, AddinDescription desc)
{
this.Build();
this.project = project;
this.registry = registry;
this.desc = desc;
foreach (AddinDependency adep in desc.MainModule.Dependencies) {
Addin addin = registry.GetAddin (adep.FullAddinId);
if (addin != null && addin.Description != null) {
foreach (ExtensionNodeSet ns in addin.Description.ExtensionNodeSets) {
combo.AppendText (ns.Id);
sets [ns.Id] = ns;
}
}
}
foreach (ExtensionNodeSet ns in desc.ExtensionNodeSets) {
combo.AppendText (ns.Id);
sets [ns.Id] = ns;
}
nodeseteditor.AllowEditing = false;
buttonOk.Sensitive = false;
}
public Project (DotNetProject project)
: this (
project,
PackageManagementExtendedServices.ProjectService,
new PackageManagementFileService ())
{
}
protected SolutionItemConfiguration CreateConfigurationBlock(MonoDevelop.Projects.DotNetProject project, Config ConfigBlock, string AssemblyName, string OuputType, IProgressMonitor monitor)
{
DotNetProjectConfiguration confObj = project.CreateConfiguration(ConfigBlock.Name) as DotNetProjectConfiguration;
confObj.RunWithWarnings = false;
confObj.DebugMode = ConfigBlock.DebugSymbols;
project.CompileTarget = (CompileTarget)Enum.Parse(typeof(CompileTarget), OuputType, true);
string dir = MapPath(project.BaseDirectory, ConfigBlock.OutputPath);
if (dir == null)
{
dir = Path.Combine("bin", ConfigBlock.Name);
monitor.ReportWarning(string.Format(GettextCatalog.GetString("Output directory '{0}' can't be mapped to a local directory. The directory '{1}' will be used instead"), ConfigBlock.OutputPath, dir));
}
confObj.OutputDirectory = dir;
confObj.OutputAssembly = AssemblyName;
CSharpCompilerParameters compilerParams = new CSharpCompilerParameters();
compilerParams.WarningLevel = ConfigBlock.WarningLevel;
compilerParams.NoWarnings = "";
compilerParams.Optimize = ConfigBlock.Optimize;
compilerParams.DefineSymbols = ConfigBlock.DefineConstants;
compilerParams.UnsafeCode = ConfigBlock.AllowUnsafeBlocks;
compilerParams.GenerateOverflowChecks = ConfigBlock.CheckForOverflowUnderflow;
return(confObj);
}
public MonoSolutionItemHandler (DotNetProject project)
{
this.project = project;
project.FileAddedToProject += OnFileAddedToProject;
project.FileRemovedFromProject += OnFileRemovedFromProject;
project.FileRenamedInProject += OnFileRenamedInProject;
}
public ProjectReferencesFromPackagesFolderNode (
DotNetProject project,
ProjectReferenceCollection projectReferences)
{
Project = project;
References = projectReferences;
}
public References (
MD.DotNetProject project,
IExtendedPackageManagementProjectService projectService)
{
this.msbuildProject = project;
this.projectService = projectService;
}
public CompilerOptionsPanelWidget(DotNetProject project)
{
this.Build();
this.project = project;
DotNetProjectConfiguration configuration = (DotNetProjectConfiguration) project.GetActiveConfiguration (IdeApp.Workspace.ActiveConfiguration);
FSharpCompilerParameters compilerParameters = (FSharpCompilerParameters) configuration.CompilationParameters;
ListStore store = new ListStore (typeof (string));
store.AppendValues (GettextCatalog.GetString ("Executable"));
store.AppendValues (GettextCatalog.GetString ("Library"));
store.AppendValues (GettextCatalog.GetString ("Executable with GUI"));
store.AppendValues (GettextCatalog.GetString ("Module"));
compileTargetCombo.Model = store;
CellRendererText cr = new CellRendererText ();
compileTargetCombo.PackStart (cr, true);
compileTargetCombo.AddAttribute (cr, "text", 0);
compileTargetCombo.Active = (int) configuration.CompileTarget;
compileTargetCombo.Changed += new EventHandler (OnTargetChanged);
// Load the codepage. If it matches any of the supported encodigs, use the encoding name
string foundEncoding = null;
foreach (TextEncoding e in TextEncoding.SupportedEncodings) {
if (e.CodePage == -1)
continue;
if (e.CodePage == compilerParameters.CodePage)
foundEncoding = e.Id;
codepageEntry.AppendText (e.Id);
}
if (foundEncoding != null)
codepageEntry.Entry.Text = foundEncoding;
else if (compilerParameters.CodePage != 0)
codepageEntry.Entry.Text = compilerParameters.CodePage.ToString ();
}
public GuiBuilderProject (DotNetProject project, string fileName)
{
this.fileName = fileName;
this.project = project;
Counters.GuiProjectsLoaded++;
GuiBuilderService.NotifyGuiProjectLoaded ();
}
public NuGetProject CreateNuGetProject (DotNetProject project, INuGetProjectContext context)
{
Runtime.AssertMainThread ();
var nugetAwareProject = project as INuGetAwareProject;
if (nugetAwareProject != null)
return nugetAwareProject.CreateNuGetProject ();
var projectSystem = new MonoDevelopMSBuildNuGetProjectSystem (project, context);
string projectJsonPath = ProjectJsonPathUtilities.GetProjectConfigPath (project.BaseDirectory, project.Name);
if (File.Exists (projectJsonPath)) {
return new BuildIntegratedProjectSystem (
projectJsonPath,
project.FileName,
project,
projectSystem,
project.Name,
settings);
}
string baseDirectory = GetBaseDirectory (project);
string folderNuGetProjectFullPath = PackagesFolderPathUtility.GetPackagesFolderPath (baseDirectory, settings);
string packagesConfigFolderPath = project.BaseDirectory;
return new MSBuildNuGetProject (
projectSystem,
folderNuGetProjectFullPath,
packagesConfigFolderPath);
}
public CompilerOptionsPanelWidget (DotNetProject project)
{
this.Build();
this.project = project;
DotNetProjectConfiguration configuration = (DotNetProjectConfiguration) project.GetConfiguration (IdeApp.Workspace.ActiveConfiguration);
CSharpCompilerParameters compilerParameters = (CSharpCompilerParameters) configuration.CompilationParameters;
CSharpProjectParameters projectParameters = (CSharpProjectParameters) configuration.ProjectParameters;
ListStore store = new ListStore (typeof (string));
store.AppendValues (GettextCatalog.GetString ("Executable"));
store.AppendValues (GettextCatalog.GetString ("Library"));
store.AppendValues (GettextCatalog.GetString ("Executable with GUI"));
store.AppendValues (GettextCatalog.GetString ("Module"));
compileTargetCombo.Model = store;
CellRendererText cr = new CellRendererText ();
compileTargetCombo.PackStart (cr, true);
compileTargetCombo.AddAttribute (cr, "text", 0);
compileTargetCombo.Active = (int) configuration.CompileTarget;
compileTargetCombo.Changed += new EventHandler (OnTargetChanged);
if (project.IsLibraryBasedProjectType) {
//fixme: should we totally hide these?
compileTargetCombo.Sensitive = false;
mainClassEntry.Sensitive = false;
} else {
classListStore = new ListStore (typeof(string));
mainClassEntry.Model = classListStore;
mainClassEntry.TextColumn = 0;
((Entry)mainClassEntry.Child).Text = projectParameters.MainClass ?? string.Empty;
UpdateTarget ();
}
// Load the codepage. If it matches any of the supported encodigs, use the encoding name
string foundEncoding = null;
foreach (TextEncoding e in TextEncoding.SupportedEncodings) {
if (e.CodePage == -1)
continue;
if (e.CodePage == projectParameters.CodePage)
foundEncoding = e.Id;
codepageEntry.AppendText (e.Id);
}
if (foundEncoding != null)
codepageEntry.Entry.Text = foundEncoding;
else if (projectParameters.CodePage != 0)
codepageEntry.Entry.Text = projectParameters.CodePage.ToString ();
iconEntry.Path = projectParameters.Win32Icon;
iconEntry.DefaultPath = project.BaseDirectory;
allowUnsafeCodeCheckButton.Active = compilerParameters.UnsafeCode;
noStdLibCheckButton.Active = compilerParameters.NoStdLib;
ListStore langVerStore = new ListStore (typeof (string));
langVerStore.AppendValues (GettextCatalog.GetString ("Default"));
langVerStore.AppendValues ("ISO-1");
langVerStore.AppendValues ("ISO-2");
langVerCombo.Model = langVerStore;
langVerCombo.Active = (int) compilerParameters.LangVersion;
}
// internal static ProjectItem FindByEntity (IProject project, IEntity entity)
// {
// if (entity.Region.FileName != null) {
// return FindByFileName (project, entity.Region.FileName);
// }
// return null;
// }
internal static ProjectItem FindByFileName(MD.DotNetProject project, string fileName)
{
// MD.ProjectFile item = project.FindFile (new FileName (fileName));
// if (item != null) {
// return new ProjectItem (new Project (project), item);
// }
return(null);
}
public IMonoDevelopPackageManager CreatePackageManager (
IPackageRepository sourceRepository,
DotNetProject project)
{
IMonoDevelopPackageManager packageManager = factory.CreatePackageManager (sourceRepository, project);
ProjectManager = packageManager.ProjectManager;
return packageManager;
}
/// <summary>Initializes a new instance of the WebReferenceItem class.</summary>
/// <param name="name">A string containing the name for the web reference.</param>
public WebReferenceItem (WebServiceEngine engine, DotNetProject project, string name, FilePath basePath, ProjectFile mapFile)
{
this.engine = engine;
this.name = name;
this.project = project;
this.mapFile = mapFile;
BasePath = basePath.CanonicalPath;
}
public static bool SupportsRefactoring(DotNetProject project)
{
if (project == null || project.LanguageBinding == null || project.LanguageBinding.GetCodeDomProvider () == null)
return false;
RefactorOperations ops = RefactorOperations.AddField | RefactorOperations.AddMethod | RefactorOperations.RenameField | RefactorOperations.AddAttribute;
CodeRefactorer cref = IdeApp.Workspace.GetCodeRefactorer (project.ParentSolution);
return cref.LanguageSupportsOperation (project.LanguageBinding.Language, ops);
}
public override void Initialize (OptionsDialog dialog, object dataObject)
{
project = dataObject as DotNetProject;
propertyGroup = project.MSBuildProject.GetNuGetMetadataPropertyGroup ();
packOnBuild = propertyGroup.GetValue ("PackOnBuild", false);
base.Initialize (dialog, dataObject);
}
public XcodeProjectTracker (DotNetProject dnp, NSObjectInfoService infoService)
{
if (dnp == null)
throw new ArgumentNullException ("dnp");
this.dnp = dnp;
this.infoService = infoService;
AppleSdkSettings.Changed += DisableSyncing;
}
public async Task GetTypes(MonoDevelop.Projects.DotNetProject project)
{
TypeNamesList = new List <string> ();
var ctx = await IdeApp.TypeSystemService.GetCompilationAsync(project);
TypesList = new List <INamedTypeSymbol> (ctx.GetAllTypesInMainAssembly());
foreach (var typeDef in TypesList)
{
TypeNamesList.Add(Ambience.EscapeText(typeDef.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)));
}
}
internal static string GetProjectKind(MD.DotNetProject project)
{
string type = ProjectType.GetProjectType(project);
if (type == ProjectType.CSharp)
{
return(CSharp);
}
else if (type == ProjectType.VB)
{
return(VBNet);
}
return(string.Empty);
}
void RegisterReference(MonoDevelop.Projects.DotNetProject project)
{
var dnp = project;
var pr = base.Type.GetProjectReference();
//add the reference if it doesn't match an existing one
bool match = false;
foreach (var p in dnp.References)
{
if (p.Equals(pr))
{
match = true;
}
}
if (!match)
{
dnp.References.Add(pr);
}
}
void PopulateSupportFileList(FileCopySet list, ConfigurationSelector configuration, int referenceDistance)
{
if (referenceDistance < 2)
{
base.PopulateSupportFileList(list, configuration);
}
//rename the app.config file
FileCopySet.Item appConfig = list.Remove("app.config");
if (appConfig == null)
{
appConfig = list.Remove("App.config");
}
if (appConfig != null)
{
string output = Path.GetFileName(GetOutputFileName(configuration));
list.Add(appConfig.Src, appConfig.CopyOnlyIfNewer, output + ".config");
}
//collect all the "local copy" references and their attendant files
foreach (ProjectReference projectReference in References)
{
if (!projectReference.LocalCopy || ParentSolution == null)
{
continue;
}
if (projectReference.ReferenceType == ReferenceType.Project)
{
DotNetProject p = ParentSolution.FindProjectByName(projectReference.Reference) as DotNetProject;
if (p == null)
{
LoggingService.LogWarning("Project '{0}' referenced from '{1}' could not be found", projectReference.Reference, this.Name);
continue;
}
string refOutput = p.GetOutputFileName(configuration);
if (string.IsNullOrEmpty(refOutput))
{
LoggingService.LogWarning("Project '{0}' referenced from '{1}' has an empty output filename", p.Name, this.Name);
continue;
}
list.Add(refOutput);
//VS COMPAT: recursively copy references's "local copy" files
//but only copy the "copy to output" files from the immediate references
p.PopulateSupportFileList(list, configuration, referenceDistance + 1);
DotNetProjectConfiguration refConfig = p.GetConfiguration(configuration) as DotNetProjectConfiguration;
if (refConfig != null && refConfig.DebugMode)
{
string mdbFile = TargetRuntime.GetAssemblyDebugInfoFile(refOutput);
if (File.Exists(mdbFile))
{
list.Add(mdbFile);
}
}
}
else if (projectReference.ReferenceType == ReferenceType.Assembly)
{
// VS COMPAT: Copy the assembly, but also all other assemblies referenced by it
// that are located in the same folder
foreach (string file in GetAssemblyRefsRec(projectReference.Reference, new HashSet <string> ()))
{
list.Add(file);
if (File.Exists(file + ".config"))
{
list.Add(file + ".config");
}
string mdbFile = TargetRuntime.GetAssemblyDebugInfoFile(file);
if (File.Exists(mdbFile))
{
list.Add(mdbFile);
}
}
}
else if (projectReference.ReferenceType == ReferenceType.Custom)
{
foreach (string refFile in projectReference.GetReferencedFileNames(configuration))
{
list.Add(refFile);
}
}
}
}
public async Task MakefileSynchronization()
{
if (Platform.IsWindows)
{
Assert.Ignore();
}
string solFile = Util.GetSampleProject("console-project-with-makefile", "ConsoleProject.sln");
Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
DotNetProject p = (DotNetProject)sol.Items [0];
Assert.AreEqual(2, p.Files.Count);
string f = Path.Combine(p.BaseDirectory, "Program.cs");
Assert.IsTrue(p.Files.GetFile(f) != null, "Contains Program.cs");
f = Path.Combine(p.BaseDirectory, "Properties");
f = Path.Combine(f, "AssemblyInfo.cs");
Assert.IsTrue(p.Files.GetFile(f) != null, "Contains Properties/AssemblyInfo.cs");
List <string> refs = new List <string> ();
refs.Add("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
refs.Add("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
refs.Add("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
Assert.AreEqual(3, p.References.Count);
ProjectReference xmlRef = null;
foreach (ProjectReference pref in p.References)
{
Assert.IsTrue(refs.Contains(pref.Reference), "Contains reference " + pref.Reference);
refs.Remove(pref.Reference);
if (pref.Reference.StartsWith("System.Xml"))
{
xmlRef = pref;
}
}
// Test saving
p.References.Remove(xmlRef);
p.References.Add(ProjectReference.CreateAssemblyReference("System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
p.Files.Remove(f);
p.Files.Add(new ProjectFile(Path.Combine(p.BaseDirectory, "Class1.cs"), BuildAction.Compile));
await sol.SaveAsync(Util.GetMonitor());
string makefile = File.ReadAllText(Path.Combine(p.BaseDirectory, "Makefile"));
string[] values = GetVariable(makefile, "FILES").Split(' ');
Assert.AreEqual(2, values.Length);
Assert.AreEqual("Class1.cs", values [0]);
Assert.AreEqual("Program.cs", values [1]);
values = GetVariable(makefile, "REFERENCES").Split(' ');
Assert.AreEqual(3, values.Length);
Assert.AreEqual("System", values [0]);
Assert.AreEqual("System.Data", values [1]);
Assert.AreEqual("System.Web", values [2]);
sol.Dispose();
}
string GetConfigFolderName(DotNetProject lib, string conf)
{
return(Path.GetFileName(Path.GetDirectoryName(lib.GetOutputFileName((SolutionConfigurationSelector)conf))));
}
public async Task BuildingAndCleaningSolution()
{
string solFile = Util.GetSampleProject("console-with-libs", "console-with-libs.sln");
Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
DotNetProject p = (DotNetProject)sol.FindProjectByName("console-with-libs");
DotNetProject lib1 = (DotNetProject)sol.FindProjectByName("library1");
DotNetProject lib2 = (DotNetProject)sol.FindProjectByName("library2");
SolutionFolder folder = new SolutionFolder();
folder.Name = "subfolder";
sol.RootFolder.Items.Add(folder);
sol.RootFolder.Items.Remove(lib2);
folder.Items.Add(lib2);
Workspace ws = new Workspace();
ws.FileName = Path.Combine(sol.BaseDirectory, "workspace");
ws.Items.Add(sol);
await ws.SaveAsync(Util.GetMonitor());
// Build the project and the references
BuildResult res = await ws.Build(Util.GetMonitor(), ConfigurationSelector.Default);
Assert.AreEqual(0, res.ErrorCount);
Assert.AreEqual(0, res.WarningCount);
Assert.AreEqual(3, res.BuildCount);
Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe")));
Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe"))));
Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll")));
Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll"))));
Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll")));
Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll"))));
// Clean the workspace
await ws.Clean(Util.GetMonitor(), ConfigurationSelector.Default);
Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe")));
Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe"))));
Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll")));
Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll"))));
Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll")));
Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll"))));
// Build the solution
res = await ws.Build(Util.GetMonitor(), ConfigurationSelector.Default);
Assert.AreEqual(0, res.ErrorCount);
Assert.AreEqual(0, res.WarningCount);
Assert.AreEqual(3, res.BuildCount);
Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe")));
Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe"))));
Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll")));
Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll"))));
Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll")));
Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll"))));
// Clean the solution
await sol.Clean(Util.GetMonitor(), "Debug");
Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe")));
Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe"))));
Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll")));
Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll"))));
Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll")));
Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll"))));
// Build the solution folder
res = await folder.Build(Util.GetMonitor(), (SolutionConfigurationSelector)"Debug");
Assert.AreEqual(0, res.ErrorCount);
Assert.AreEqual(0, res.WarningCount);
Assert.AreEqual(1, res.BuildCount);
Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe")));
Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe"))));
Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll")));
Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll"))));
Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll")));
Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll"))));
// Clean the solution folder
await folder.Clean(Util.GetMonitor(), (SolutionConfigurationSelector)"Debug");
Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll")));
Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll"))));
sol.Dispose();
}
public async Task RefreshReferences()
{
string solFile = Util.GetSampleProject("reference-refresh", "ConsoleProject.sln");
Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
DotNetProject project = sol.GetAllItems <DotNetProject> ().FirstOrDefault();
Assert.AreEqual(4, project.References.Count);
ProjectReference r;
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "test");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("test.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "gtk-sharp");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
// Refresh without any change
project.RefreshReferenceStatus();
Assert.AreEqual(4, project.References.Count);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "test");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("test.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "gtk-sharp");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
// Refresh after deleting test.dll
File.Move(project.BaseDirectory.Combine("test.dll"), project.BaseDirectory.Combine("test.dll.tmp"));
project.RefreshReferenceStatus();
Assert.AreEqual(4, project.References.Count);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "test");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsFalse(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "gtk-sharp");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
// Refresh after deleting gtk-sharp.dll
File.Move(project.BaseDirectory.Combine("gtk-sharp.dll"), project.BaseDirectory.Combine("gtk-sharp.dll.tmp"));
project.RefreshReferenceStatus();
Assert.AreEqual(4, project.References.Count);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "test");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsFalse(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("gtk-sharp,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.AreEqual("gtk-sharp.dll", Path.GetFileName(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single()));
Assert.IsTrue(r.IsValid);
// Refresh after restoring gtk-sharp.dll and test.dll
File.Move(project.BaseDirectory.Combine("test.dll.tmp"), project.BaseDirectory.Combine("test.dll"));
File.Move(project.BaseDirectory.Combine("gtk-sharp.dll.tmp"), project.BaseDirectory.Combine("gtk-sharp.dll"));
project.RefreshReferenceStatus();
Assert.AreEqual(4, project.References.Count);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Package);
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference == "test");
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("test.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
r = project.References.FirstOrDefault(re => re.Reference.StartsWith("gtk-sharp,"));
Assert.IsNotNull(r);
Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly);
Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString());
Assert.IsTrue(r.IsValid);
}
internal protected virtual bool OnGetCanReferenceProject(DotNetProject targetProject, out string reason)
{
return(next.OnGetCanReferenceProject(targetProject, out reason));
}
public override IEnumerable <string> GetReferencedAssemblies(DotNetProject project, ConfigurationSelector configuration, bool includeProjectReferences)
{
return(project.OnGetReferencedAssemblies(configuration, includeProjectReferences));
}
public static void CheckResourcesSolution(Solution sol)
{
DotNetProject p = (DotNetProject)sol.Items [0];
Assert.AreEqual("ResourcesTesterNamespace", p.DefaultNamespace);
string f = Path.Combine(p.BaseDirectory, "Bitmap1.bmp");
ProjectFile pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Bitmap1.bmp not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Bitmap1.bmp", pf.ResourceId);
f = Path.Combine(p.BaseDirectory, "BitmapCultured.ca.bmp");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "BitmapCultured.ca.bmp not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.BitmapCultured.bmp", pf.ResourceId);
f = Path.Combine(p.BaseDirectory, "Cultured.ca.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Cultured.ca.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Cultured.ca.resources", pf.ResourceId);
f = Path.Combine(p.BaseDirectory, "FormFile.ca.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "FormFile.ca.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTester.Form1.ca.resources", pf.ResourceId);
f = Path.Combine(p.BaseDirectory, "FormFile.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "FormFile.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTester.Form1.resources", pf.ResourceId);
f = Path.Combine(p.BaseDirectory, "Normal.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Normal.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Normal.resources", pf.ResourceId);
string subdir = Path.Combine(p.BaseDirectory, "Subfolder");
f = Path.Combine(subdir, "Bitmap2.bmp");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Subfolder/Bitmap2.bmp not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Subfolder.Bitmap2.bmp", pf.ResourceId);
f = Path.Combine(subdir, "BitmapCultured2.ca.bmp");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Subfolder/BitmapCultured2.ca.bmp not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Subfolder.BitmapCultured2.bmp", pf.ResourceId);
f = Path.Combine(subdir, "Cultured2.ca.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Subfolder/Cultured2.ca.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Subfolder.Cultured2.ca.resources", pf.ResourceId);
f = Path.Combine(subdir, "FormFile2.ca.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Subfolder/FormFile2.ca.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTester.Form2.ca.resources", pf.ResourceId);
f = Path.Combine(subdir, "FormFile2.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Subfolder/FormFile2.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTester.Form2.resources", pf.ResourceId);
f = Path.Combine(subdir, "Normal2.resx");
pf = p.Files.GetFile(f);
Assert.IsNotNull(pf, "Subfolder/Normal2.resx not found");
Assert.AreEqual(BuildAction.EmbeddedResource, pf.BuildAction);
Assert.AreEqual("ResourcesTesterNamespace.Subfolder.Normal2.resources", pf.ResourceId);
}
internal void SetOwnerProject(DotNetProject project)
{
ownerProject = project;
UpdatePackageReference();
}
public static Solution CreateProjectWithFolders(string hint)
{
string dir = Util.CreateTmpDir(hint);
Directory.CreateDirectory(Util.Combine(dir, "console-project"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution1"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution1", "library1"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution1", "library2"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution2"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution2", "console-project2"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution2", "nested-solution3"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution2", "nested-solution3", "library3"));
Directory.CreateDirectory(Util.Combine(dir, "nested-solution2", "nested-solution3", "library4"));
Solution sol = new Solution();
sol.FileName = Path.Combine(dir, "nested-solutions-mdp");
SolutionConfiguration scDebug = sol.AddConfiguration("Debug", true);
SolutionConfiguration scRelease = sol.AddConfiguration("Release", true);
DotNetProject project1 = CreateProject(Util.Combine(dir, "console-project"), "C#", "console-project");
project1.Files.Add(new ProjectFile(Path.Combine(project1.BaseDirectory, "Program.cs")));
project1.Files.Add(new ProjectFile(Path.Combine(project1.BaseDirectory, "Properties", "AssemblyInfo.cs")));
sol.RootFolder.Items.Add(project1);
// nested-solution1
SolutionFolder folder1 = new SolutionFolder();
sol.RootFolder.Items.Add(folder1);
folder1.Name = "nested-solution1";
DotNetProject projectLib1 = CreateProject(Util.Combine(dir, "nested-solution1", "library1"), "C#", "library1");
projectLib1.References.Add(new ProjectReference(ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
projectLib1.Files.Add(new ProjectFile(Path.Combine(projectLib1.BaseDirectory, "MyClass.cs")));
projectLib1.Files.Add(new ProjectFile(Path.Combine(projectLib1.BaseDirectory, "Properties", "AssemblyInfo.cs")));
projectLib1.CompileTarget = CompileTarget.Library;
folder1.Items.Add(projectLib1);
DotNetProject projectLib2 = CreateProject(Util.Combine(dir, "nested-solution1", "library2"), "C#", "library2");
projectLib2.References.Add(new ProjectReference(ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
projectLib2.Files.Add(new ProjectFile(Path.Combine(projectLib2.BaseDirectory, "MyClass.cs")));
projectLib2.Files.Add(new ProjectFile(Path.Combine(projectLib2.BaseDirectory, "Properties", "AssemblyInfo.cs")));
projectLib2.CompileTarget = CompileTarget.Library;
folder1.Items.Add(projectLib2);
// nested-solution2
SolutionFolder folder2 = new SolutionFolder();
folder2.Name = "nested-solution2";
sol.RootFolder.Items.Add(folder2);
DotNetProject project2 = CreateProject(Util.Combine(dir, "nested-solution2", "console-project2"), "C#", "console-project2");
project2.Files.Add(new ProjectFile(Path.Combine(project2.BaseDirectory, "Program.cs")));
project2.Files.Add(new ProjectFile(Path.Combine(project2.BaseDirectory, "Properties", "AssemblyInfo.cs")));
project2.References.Add(new ProjectReference(ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
// nested-solution3
SolutionFolder folder3 = new SolutionFolder();
folder3.Name = "nested-solution3";
DotNetProject projectLib3 = CreateProject(Util.Combine(dir, "nested-solution2", "nested-solution3", "library3"), "C#", "library3");
projectLib3.References.Add(new ProjectReference(ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
projectLib3.Files.Add(new ProjectFile(Path.Combine(projectLib3.BaseDirectory, "MyClass.cs")));
projectLib3.Files.Add(new ProjectFile(Path.Combine(projectLib3.BaseDirectory, "Properties", "AssemblyInfo.cs")));
projectLib3.CompileTarget = CompileTarget.Library;
folder3.Items.Add(projectLib3);
DotNetProject projectLib4 = CreateProject(Util.Combine(dir, "nested-solution2", "nested-solution3", "library4"), "C#", "library4");
projectLib4.References.Add(new ProjectReference(ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
projectLib4.Files.Add(new ProjectFile(Path.Combine(projectLib4.BaseDirectory, "MyClass.cs")));
projectLib4.Files.Add(new ProjectFile(Path.Combine(projectLib4.BaseDirectory, "Properties", "AssemblyInfo.cs")));
projectLib4.CompileTarget = CompileTarget.Library;
folder3.Items.Add(projectLib4);
folder2.Items.Add(folder3);
folder2.Items.Add(project2);
string file = Path.Combine(dir, "TestSolution.sln");
sol.FileName = file;
project1.References.Add(new ProjectReference(ReferenceType.Package, "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
project1.References.Add(new ProjectReference(projectLib1));
project1.References.Add(new ProjectReference(projectLib2));
project1.References.Add(new ProjectReference(projectLib3));
project1.References.Add(new ProjectReference(projectLib4));
project2.References.Add(new ProjectReference(projectLib3));
project2.References.Add(new ProjectReference(projectLib4));
Assert.AreEqual(2, sol.Configurations.Count);
Assert.AreEqual(6, scDebug.Configurations.Count);
Assert.AreEqual(6, scRelease.Configurations.Count);
return(sol);
}
public virtual IEnumerable <string> GetReferencedAssemblies(DotNetProject project, ConfigurationSelector configuration, bool includeProjectReferences)
{
return(GetNext(project).GetReferencedAssemblies(project, configuration, includeProjectReferences));
}
/// <summary>
/// Currently this project extension is enabled for all SDK style projects and
/// not just for .NET Core and .NET Standard projects. SDK project support
/// should be separated out from this extension so it can be enabled only for
/// .NET Core and .NET Standard projects.
/// </summary>
bool IsSdkProject(DotNetProject project)
{
return(project.MSBuildProject.GetReferencedSDKs().Length > 0);
}
public References(MD.DotNetProject project)
: this(project, PackageManagementExtendedServices.ProjectService)
{
}
