private bool NeedsReferenceAssemblyPackages()
{
// Check to see if NuGet packages for reference assemblies need to be referenced (because
// the targeting pack is not installed)
bool needsReferenceAssemblyPackages = false;
if (IsSdkProject)
{
foreach (var shortFrameworkName in TargetFrameworks.Split(';').Where(tf => GetShortTargetFrameworkIdentifier(tf) == "net"))
{
// Normalize version to the form used in the reference assemblies path
var version = NuGetFramework.Parse(shortFrameworkName).Version;
version = new Version(version.Major, version.Minor, version.Build);
if (version.Build == 0)
{
version = new Version(version.Major, version.Minor);
}
if (!ReferenceAssembliesAreInstalled(version.ToString()))
{
needsReferenceAssemblyPackages = true;
}
}
}
else
{
needsReferenceAssemblyPackages = !ReferenceAssembliesAreInstalled(TargetFrameworkVersion);
}
return(needsReferenceAssemblyPackages);
}
private void ParseTargetFrameworks(List <Framework> parsedFrameworkList)
{
string[] Frameworks = TargetFrameworks.Split(';');
foreach (string Framework in Frameworks)
{
ParseTargetFramework(parsedFrameworkList, Framework);
}
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
var projectXml = XDocument.Load(sourceProject);
var ns = XNamespace.Get("http://schemas.microsoft.com/developer/msbuild/2003");
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.First();
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
// If there are any targets that aren't .NET Framework, add appropriate package reference
if (targetFrameworks.Any(identifier => !GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
XElement packageReference;
if (this.IsExe)
{
packageReference = new XElement(ns + "PackageReference",
new XAttribute("Include", "Microsoft.NETCore.App"),
new XAttribute("Version", "1.0.1")
);
}
else
{
packageReference = new XElement(ns + "PackageReference",
new XAttribute("Include", "NETStandard.Library"),
new XAttribute("Version", "1.6.0")
);
}
if (targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
string condition = null;
foreach (var target in targetFrameworks)
{
if (!GetShortTargetFrameworkIdentifier(target).Equals("net", StringComparison.OrdinalIgnoreCase))
{
if (condition == null)
{
condition = "";
}
else
{
condition += " Or ";
}
condition += $"'$(TargetFramework)' == '{target}'";
}
}
packageReference.SetAttributeValue("Condition", condition);
}
packageReferenceItemGroup.Add(packageReference);
}
if (this.IsExe && targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", "win7-x86"));
}
// Update SDK reference to the version under test
projectXml.Descendants(ns + "PackageReference")
.FirstOrDefault(pr => pr.Attribute("Include")?.Value == "Microsoft.NET.Sdk")
?.Element(ns + "Version")
?.SetValue('[' + targetTestAsset.BuildVersion + ']');
}
else
{
var targetFrameworkVersionElement = propertyGroup.Element(ns + "TargetFrameworkVersion");
targetFrameworkVersionElement.SetValue(this.TargetFrameworkVersion);
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
}}
}}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
// Copy any additional files from template
foreach (var file in Directory.GetFiles(Path.GetDirectoryName(sourceProject)))
{
if (file != sourceProject)
{
File.Copy(file, Path.Combine(targetFolder, Path.GetFileName(file)));
}
}
var projectXml = XDocument.Load(sourceProject);
var ns = projectXml.Root.Name.Namespace;
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault();
}
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
foreach (TestPackageReference packageReference in PackageReferences)
{
var packageReferenceElement = new XElement(ns + "PackageReference",
new XAttribute("Include", packageReference.ID));
if (packageReference.Version != null)
{
packageReferenceElement.Add(new XAttribute("Version", packageReference.Version));
}
if (packageReference.PrivateAssets != null)
{
packageReferenceElement.Add(new XAttribute("PrivateAssets", packageReference.PrivateAssets));
}
packageReferenceItemGroup.Add(packageReferenceElement);
}
foreach (TestPackageReference dotnetCliToolReference in DotNetCliToolReferences)
{
packageReferenceItemGroup.Add(new XElement(ns + "DotNetCliToolReference",
new XAttribute("Include", $"{dotnetCliToolReference.ID}"),
new XAttribute("Version", $"{dotnetCliToolReference.Version}")));
}
// If targeting .NET Framework and a required targeting pack isn't installed, add a
// PackageReference to get the targeting pack from a NuGet package
if (NeedsReferenceAssemblyPackages())
{
packageReferenceItemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"Microsoft.NETFramework.ReferenceAssemblies"),
new XAttribute("Version", $"1.0.0-alpha-5")));
propertyGroup.Add(new XElement(ns + "RestoreAdditionalProjectSources", "$(RestoreAdditionalProjectSources);https://dotnet.myget.org/F/roslyn-tools/api/v3/index.json"));
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
if (!string.IsNullOrEmpty(this.RuntimeFrameworkVersion))
{
propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", this.RuntimeFrameworkVersion));
}
if (!string.IsNullOrEmpty(this.RuntimeIdentifier))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", this.RuntimeIdentifier));
}
}
else
{
if (!string.IsNullOrEmpty(this.TargetFrameworkProfile))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworkProfile", this.TargetFrameworkProfile));
// To construct an accurate PCL project file, we must modify the import of the CSharp targets;
// building/testing the SDK requires a VSDev command prompt which sets 'VSINSTALLDIR'
var importGroup = projectXml.Root.Elements(ns + "Import").Last();
importGroup.Attribute("Project").Value = "$(VSINSTALLDIR)\\MSBuild\\Microsoft\\Portable\\$(TargetFrameworkVersion)\\Microsoft.Portable.CSharp.targets";
}
propertyGroup.Element(ns + "TargetFrameworkVersion").SetValue(this.TargetFrameworkVersion);
}
foreach (var additionalProperty in AdditionalProperties)
{
propertyGroup.Add(new XElement(ns + additionalProperty.Key, additionalProperty.Value));
}
if (AdditionalItems.Any())
{
foreach (var additionalItem in AdditionalItems)
{
var additionalItemGroup = projectXml.Root.Elements(ns + "ItemGroup").FirstOrDefault();
if (additionalItemGroup == null)
{
additionalItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
additionalItemGroup.Add(new XElement(
ns + additionalItem.Key,
new XAttribute("Include", additionalItem.Value)));
}
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
if (this.References.Any())
{
var referenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "Reference").Count() > 0);
if (referenceItemGroup == null)
{
referenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(referenceItemGroup);
}
foreach (var reference in References)
{
referenceItemGroup.Add(new XElement(ns + "Reference",
new XAttribute("Include", reference)));
}
}
if (this.CopyFilesTargets.Any())
{
foreach (var copyFilesTarget in CopyFilesTargets)
{
var target = new XElement(ns + "Target",
new XAttribute("Name", copyFilesTarget.TargetName),
new XAttribute("AfterTargets", copyFilesTarget.TargetToRunAfter));
target.Add(new XElement(ns + "Copy",
new XAttribute("SourceFiles", copyFilesTarget.SourceFiles),
new XAttribute("DestinationFolder", copyFilesTarget.Destination)));
projectXml.Root.Add(target);
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.List);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
using System.Collections.Generic;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
public static List<string> List {{ get {{ return null; }} }}
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" public string {dependency.Name}Name {{ get {{ return {dependency.Name}.{dependency.Name}Class.Name; }} }}" + Environment.NewLine;
source += $" public List<string> {dependency.Name}List {{ get {{ return {dependency.Name}.{dependency.Name}Class.List; }} }}" + Environment.NewLine;
}
source +=
@" }
}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
foreach (var kvp in EmbeddedResources)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
var projectXml = XDocument.Load(sourceProject);
var ns = projectXml.Root.Name.Namespace;
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault();
}
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
foreach (TestPackageReference packageReference in PackageReferences)
{
packageReferenceItemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"{packageReference.ID}"),
new XAttribute("Version", $"{packageReference.Version}")));
}
foreach (TestPackageReference dotnetCliToolReference in DotNetCliToolReferences)
{
packageReferenceItemGroup.Add(new XElement(ns + "DotNetCliToolReference",
new XAttribute("Include", $"{dotnetCliToolReference.ID}"),
new XAttribute("Version", $"{dotnetCliToolReference.Version}")));
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
if (!string.IsNullOrEmpty(this.RuntimeFrameworkVersion))
{
propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", this.RuntimeFrameworkVersion));
}
if (!string.IsNullOrEmpty(this.RuntimeIdentifier))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", this.RuntimeIdentifier));
}
// Update SDK reference to the version under test
targetTestAsset.SetSdkVersion(projectXml);
}
else
{
if (!string.IsNullOrEmpty(this.TargetFrameworkProfile))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworkProfile", this.TargetFrameworkProfile));
// To construct an accurate PCL project file, we must modify the import of the CSharp targets;
// building/testing the SDK requires a VSDev command prompt which sets 'VSINSTALLDIR'
var importGroup = projectXml.Root.Elements(ns + "Import").Last();
importGroup.Attribute("Project").Value = "$(VSINSTALLDIR)\\MSBuild\\Microsoft\\Portable\\$(TargetFrameworkVersion)\\Microsoft.Portable.CSharp.targets";
}
propertyGroup.Element(ns + "TargetFrameworkVersion").SetValue(this.TargetFrameworkVersion);
}
foreach (var additionalProperty in AdditionalProperties)
{
propertyGroup.Add(new XElement(ns + additionalProperty.Key, additionalProperty.Value));
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
if (this.References.Any())
{
var referenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "Reference").Count() > 0);
if (referenceItemGroup == null)
{
referenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(referenceItemGroup);
}
foreach (var reference in References)
{
referenceItemGroup.Add(new XElement(ns + "Reference",
new XAttribute("Include", reference)));
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.List);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
using System.Collections.Generic;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
public static List<string> List {{ get {{ return null; }} }}
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" public string {dependency.Name}Name {{ get {{ return {dependency.Name}.{dependency.Name}Class.Name; }} }}" + Environment.NewLine;
source += $" public List<string> {dependency.Name}List {{ get {{ return {dependency.Name}.{dependency.Name}Class.List; }} }}" + Environment.NewLine;
}
source +=
@" }
}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
foreach (var kvp in EmbeddedResources)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
var projectXml = XDocument.Load(sourceProject);
var ns = projectXml.Root.Name.Namespace;
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault();
}
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
if (this.IsExe && targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", "win7-x86"));
}
// Update SDK reference to the version under test
targetTestAsset.SetSdkVersion(projectXml);
}
else
{
var targetFrameworkVersionElement = propertyGroup.Element(ns + "TargetFrameworkVersion");
targetFrameworkVersionElement.SetValue(this.TargetFrameworkVersion);
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
}}
}}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
}
