in Sharpmake.Generators/VisualStudio/Csproj.cs [1784:2584]
private void GenerateFiles(
CSharpProject project,
List<Project.Configuration> configurations,
ItemGroups itemGroups,
IEnumerable<string> additionalNones,
List<string> generatedFiles,
List<string> skipFiles
)
{
#region Content
foreach (var file in project.ResolvedContentFullFileNames)
{
string include = Util.PathGetRelative(_projectPathCapitalized, file);
itemGroups.Contents.Add(new ItemGroups.Content { Include = include, LinkFolder = project.GetLinkFolder(include) });
}
foreach (var content in project.AdditionalContentAlwaysCopy)
{
var includePath = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content));
itemGroups.Contents.Add(new ItemGroups.Content { Include = includePath, CopyToOutputDirectory = CopyToOutputDirectory.Always, LinkFolder = project.GetLinkFolder(includePath) });
}
foreach (var content in project.AdditionalContentCopyIfNewer)
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content));
itemGroups.Contents.Add(new ItemGroups.Content { Include = include, CopyToOutputDirectory = CopyToOutputDirectory.PreserveNewest, LinkFolder = project.GetLinkFolder(include) });
}
foreach (var content in project.AdditionalContent)
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content));
itemGroups.Contents.Add(new ItemGroups.Content { Include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content)), LinkFolder = project.GetLinkFolder(include) });
}
foreach (var content in project.AdditionalContentAlwaysIncludeInVsix)
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content));
itemGroups.Contents.Add(new ItemGroups.Content { Include = include, IncludeInVsix = "true", LinkFolder = project.GetLinkFolder(include) });
}
foreach (var content in project.AdditionalNoneAlwaysCopy)
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content));
itemGroups.Nones.Add(new ItemGroups.None { Include = include, CopyToOutputDirectory = CopyToOutputDirectory.Always, LinkFolder = project.GetLinkFolder(include) });
}
foreach (var content in project.AdditionalNoneCopyIfNewer)
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(content));
itemGroups.Nones.Add(new ItemGroups.None { Include = include, CopyToOutputDirectory = CopyToOutputDirectory.PreserveNewest, LinkFolder = project.GetLinkFolder(include) });
}
if (!string.IsNullOrWhiteSpace(project.ApplicationSplashScreen))
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(project.ApplicationSplashScreen));
itemGroups.AppSplashScreen.Add(new ItemGroups.SplashScreen { Include = include });
}
foreach (var analyzerDllFilePath in project.AnalyzerDllFilePaths)
{
string include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(analyzerDllFilePath));
itemGroups.Analyzers.Add(new ItemGroups.Analyzer { Include = include });
}
#endregion
foreach (var glob in project.Globs)
{
itemGroups.Compiles.Add(new ItemGroups.Compile { Include = glob.Include, Exclude = glob.Exclude });
}
foreach (var embeddedResource in project.AdditionalEmbeddedResourceAlwaysCopy)
{
string file = Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(embeddedResource));
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource { Include = file, CopyToOutputDirectory = CopyToOutputDirectory.Always, LinkFolder = project.GetLinkFolder(file) });
}
foreach (var embeddedResource in project.AdditionalEmbeddedResourceCopyIfNewer)
{
string file = Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(embeddedResource));
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource { Include = file, CopyToOutputDirectory = CopyToOutputDirectory.PreserveNewest, LinkFolder = project.GetLinkFolder(file) });
}
if (configurations.SelectMany(config => config.AdditionalNone).Any(noneInclude => !configurations.First().AdditionalNone.Contains(noneInclude)))
{
throw new NotImplementedException("The None files are not the same between the configurations");
}
foreach (var vsctFile in project.VsctCompileFiles)
{
itemGroups.Vscts.Add(new ItemGroups.Vsct { Include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(vsctFile)) });
}
foreach (var vsdConfigXmlFile in project.VsdConfigXmlFiles)
{
itemGroups.VsdConfigXmls.Add(new ItemGroups.VsdConfigXml { Include = Util.PathGetRelative(_projectPathCapitalized, Util.SimplifyPath(vsdConfigXmlFile)) });
}
foreach (var vsixSourceItem in project.VSIXSourceItems)
{
itemGroups.VSIXSourceItems.Add(new ItemGroups.VSIXSourceItem { Include = vsixSourceItem });
}
foreach (var protoFile in project.ProtoFiles)
{
itemGroups.Protobufs.Add(new ItemGroups.Protobuf
{
Include = Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(protoFile))
});
}
HashSet<string> allContents = new HashSet<string>(itemGroups.Contents.Select(c => c.Include));
List<string> resolvedSources = project.ResolvedSourceFiles.Select(source => Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(source))).ToList();
List<string> resolvedResources = project.ResourceFiles.Concat(project.ResolvedResourcesFullFileNames).Select(resource => Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(resource))).Distinct().ToList();
List<string> resolvedEmbeddedResource = project.ResourceFiles.Concat(project.AdditionalEmbeddedResource).Concat(project.AdditionalEmbeddedAssemblies).Select(f => Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(f))).Distinct().ToList();
List<string> resolvedNoneFiles =
(project.NoneFiles.Select(file => Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(file))))
.Concat(project.AdditionalNone.Select(f => Util.PathGetRelative(_projectPathCapitalized, Path.GetFullPath(f))))
.Where(f => !allContents.Contains(f) && !resolvedResources.Contains(f) && !resolvedEmbeddedResource.Contains(f)).Distinct().ToList();
//Add the None files from the configuration
resolvedNoneFiles = resolvedNoneFiles.Concat(
configurations.First().AdditionalNone.Select(f => Util.PathGetRelative(_projectPathCapitalized, Path.GetFullPath(f)))).ToList();
var resolvedNoneFilesAddIfNewer = project.NoneFilesCopyIfNewer
.Select(file => Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(file)))
.Where(f => !allContents.Contains(f) && !resolvedResources.Contains(f) && !resolvedEmbeddedResource.Contains(f)).Distinct().ToList();
List<string> publicResources = project.PublicResourceFiles.Select(source => Util.PathGetRelative(_projectPathCapitalized, Project.GetCapitalizedFile(source))).ToList();
#region exclusions
// None file exclusions
List<Regex> exclusionRegexs = project.SourceFilesExcludeRegex.Concat(project.SourceNoneFilesExcludeRegex).Select(p => new Regex(p, RegexOptions.Compiled | RegexOptions.IgnoreCase)).ToList();
resolvedNoneFiles = resolvedNoneFiles.Where(f =>
{
string filePath = Util.PathGetAbsolute(_projectPath, f); // LCTODO: taking the full path is too broad, and can vary depending on the location of the codebase! it needs to be fixed
return exclusionRegexs.All(r => !r.IsMatch(filePath));
}).ToList();
resolvedNoneFilesAddIfNewer = resolvedNoneFilesAddIfNewer.Where(f =>
{
string filePath = Util.PathGetAbsolute(_projectPath, f);
return exclusionRegexs.All(r => !r.IsMatch(filePath));
}).ToList();
#endregion
var remainingSourcesFiles = new List<string>(resolvedSources);
var remainingResourcesFiles = new List<string>(resolvedResources);
var remainingEmbeddedResourcesFiles = new List<string>(resolvedEmbeddedResource);
var remainingNoneFiles = new List<string>(resolvedNoneFiles);
//add none files from the first part of the generation
remainingNoneFiles.AddRange(
additionalNones.Select(f => Util.PathGetRelative(_projectPathCapitalized, Path.GetFullPath(f))));
#region global file association
List<FileAssociation> fileAssociations = FullFileNameAssociation(remainingSourcesFiles.Concat(resolvedResources).Concat(resolvedEmbeddedResource).Concat(resolvedNoneFiles));
foreach (FileAssociation fileAssociation in fileAssociations)
{
if (fileAssociation.Type == FileAssociationType.Unknown)
continue;
switch (fileAssociation.Type)
{
case FileAssociationType.Xaml:
{
string linkedCsFile = fileAssociation.GetFilenameWithExtension(".xaml.cs");
string xaml = fileAssociation.GetFilenameWithExtension(".xaml");
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = linkedCsFile,
DependentUpon = Path.GetFileName(xaml),
LinkFolder = GetProjectLinkedFolder(linkedCsFile, _projectPathCapitalized, project)
});
itemGroups.Pages.Add(new ItemGroups.Page
{
Include = xaml,
IsApplicationDefinition = project.ApplicationDefinitionFilenames.Any(f => f.Equals(Path.GetFileName(xaml), StringComparison.OrdinalIgnoreCase)),
LinkFolder = GetProjectLinkedFolder(xaml, _projectPathCapitalized, project)
});
remainingSourcesFiles.Remove(xaml);
remainingSourcesFiles.Remove(linkedCsFile);
break;
}
case FileAssociationType.Designer:
{
string designerFile = fileAssociation.GetFilenameWithExtension(".designer.cs");
string csFile = fileAssociation.GetFilenameWithExtension(".cs");
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = designerFile,
DependentUpon = Path.GetFileName(csFile),
LinkFolder = GetProjectLinkedFolder(designerFile, _projectPathCapitalized, project)
});
remainingSourcesFiles.Remove(designerFile);
string resXFile = fileAssociation.GetFilenameWithExtension(".resx");
if (resXFile != null)
{
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource
{
Include = resXFile,
DependUpon = Path.GetFileName(csFile),
LinkFolder = GetProjectLinkedFolder(resXFile, _projectPathCapitalized, project)
});
remainingEmbeddedResourcesFiles.Remove(resXFile);
remainingResourcesFiles.Remove(resXFile);
}
break;
}
case FileAssociationType.VSTOMain:
{
string mainAddinCode = fileAssociation.GetFilenameWithExtension(".cs");
string designerCode = fileAssociation.GetFilenameWithExtension(".Designer.cs");
string designerXml = fileAssociation.GetFilenameWithExtension(".Designer.xml");
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = mainAddinCode,
SubType = "Code",
LinkFolder =
GetProjectLinkedFolder(mainAddinCode, _projectPathCapitalized, project)
});
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = designerCode,
DependentUpon = designerXml,
LinkFolder =
GetProjectLinkedFolder(mainAddinCode, _projectPathCapitalized, project)
});
itemGroups.Nones.Add(new ItemGroups.None
{
Include = designerXml,
DependentUpon = mainAddinCode,
LinkFolder =
GetProjectLinkedFolder(mainAddinCode, _projectPathCapitalized, project)
});
remainingSourcesFiles.Remove(mainAddinCode);
remainingSourcesFiles.Remove(designerCode);
remainingNoneFiles.Remove(designerXml);
break;
}
case FileAssociationType.VSTORibbon:
{
string xmlFile = fileAssociation.GetFilenameWithExtension(".xml");
string csFile = fileAssociation.GetFilenameWithExtension(".cs");
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = csFile,
LinkFolder = GetProjectLinkedFolder(csFile, _projectPathCapitalized, project)
});
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource
{
Include = xmlFile,
SubType = "Designer",
Generator = RemoveLineTag,
LinkFolder = GetProjectLinkedFolder(csFile, _projectPathCapitalized, project)
});
remainingEmbeddedResourcesFiles.Remove(xmlFile);
remainingNoneFiles.Remove(xmlFile);
break;
}
case FileAssociationType.ResX:
{
string csFile = fileAssociation.GetFilenameWithExtension(".cs");
string resXFile = fileAssociation.GetFilenameWithExtension(".resx");
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource
{
Include = resXFile,
DependUpon = Path.GetFileName(csFile),
LinkFolder = GetProjectLinkedFolder(resXFile, _projectPathCapitalized, project)
});
remainingEmbeddedResourcesFiles.Remove(resXFile);
remainingResourcesFiles.Remove(resXFile);
break;
}
case FileAssociationType.AutoGenResX:
{
string designerFile = fileAssociation.GetFilenameWithExtension(".designer.cs");
string resXFile = fileAssociation.GetFilenameWithExtension(".resx");
bool publicAccessModifiers = publicResources.Any(f => f.Equals(resXFile, StringComparison.OrdinalIgnoreCase));
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = designerFile,
DependentUpon = Path.GetFileName(resXFile),
LinkFolder = GetProjectLinkedFolder(designerFile, _projectPathCapitalized, project),
AutoGen = true,
DesignTime = publicAccessModifiers ? (bool?)true : null
});
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource
{
Include = resXFile,
Generator = publicAccessModifiers ? "PublicResXFileCodeGenerator" : "ResXFileCodeGenerator",
MergeWithCto = resXFile.EndsWith("VSPackage.resx", StringComparison.OrdinalIgnoreCase) ? "true" : null,
LastGenOutput = Path.GetFileName(designerFile),
LinkFolder = GetProjectLinkedFolder(resXFile, _projectPathCapitalized, project),
SubType = "Designer"
});
remainingSourcesFiles.Remove(designerFile);
remainingEmbeddedResourcesFiles.Remove(resXFile);
remainingResourcesFiles.Remove(resXFile);
break;
}
case FileAssociationType.Settings:
{
string file = fileAssociation.GetFilenameWithExtension(".settings");
string generatedFile = fileAssociation.GetFilenameWithExtension(".designer.cs");
AddNoneGeneratedItem(itemGroups, file, generatedFile, "SettingsSingleFileGenerator", true, _projectPathCapitalized, project);
remainingSourcesFiles.Remove(generatedFile);
remainingNoneFiles.Remove(file);
break;
}
case FileAssociationType.WCF:
{
string file = fileAssociation.GetFilenameWithExtension(".svcmap");
string generatedFile = fileAssociation.GetFilenameWithExtension(".cs");
AddNoneGeneratedItem(itemGroups, file, generatedFile, "WCF Proxy Generator", false, _projectPathCapitalized, project);
remainingSourcesFiles.Remove(generatedFile);
remainingNoneFiles.Remove(file);
string wcfStorage = Path.GetDirectoryName(file);
if (wcfStorage.IndexOf(project.WcfBaseStorage, StringComparison.OrdinalIgnoreCase) < 0)
throw new Error($"WCF file storage \"{wcfStorage}\" does not match project.{nameof(project.WcfBaseStorage)}:\"{project.WcfBaseStorage}\"");
itemGroups.WCFMetadataStorages.Add(new ItemGroups.WCFMetadataStorage { Include = wcfStorage });
break;
}
case FileAssociationType.Edmx:
{
string edmxFile = fileAssociation.GetFilenameWithExtension(".edmx");
string generatedFile = fileAssociation.GetFilenameWithExtension(".designer.cs");
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = generatedFile,
AutoGen = true,
DesignTime = true,
DependentUpon = Path.GetFileName(edmxFile)
});
itemGroups.EntityDeploys.Add(new ItemGroups.EntityDeploy
{
Include = edmxFile,
Generator = "EntityModelCodeGenerator",
LastGenOutput = Path.GetFileName(generatedFile)
});
remainingSourcesFiles.Remove(generatedFile);
remainingSourcesFiles.Remove(edmxFile);
remainingNoneFiles.Remove(edmxFile);
string diagramFile = fileAssociation.GetFilenameWithExtension(".edmx.diagram");
if (diagramFile != null)
{
itemGroups.Nones.Add(new ItemGroups.None { Include = diagramFile, DependentUpon = Path.GetFileName(edmxFile) });
remainingNoneFiles.Remove(diagramFile);
}
string ttFile = fileAssociation.GetFilenameWithExtension(TTExtension);
if (ttFile != null)
{
string csModelFile = fileAssociation.GetFilenameWithExtension(".cs");
Trace.Assert(csModelFile != null);
itemGroups.Nones.Add(new ItemGroups.None
{
Include = ttFile,
Generator = "TextTemplatingFileGenerator",
DependentUpon = Path.GetFileName(edmxFile),
LastGenOutput = Path.GetFileName(csModelFile)
});
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = csModelFile,
AutoGen = true,
DesignTime = true,
DependentUpon = Path.GetFileName(ttFile)
});
// Extract all potential generated classes generated for model from .edmx definition
XDocument edmxDoc = XDocument.Load(Path.Combine(_projectPathCapitalized, edmxFile));
XNamespace edmxNS = "http://schemas.microsoft.com/ado/2009/11/edmx";
XNamespace edmNS = "http://schemas.microsoft.com/ado/2009/11/edm";
XElement cm = edmxDoc.Descendants(edmxNS + "ConceptualModels").FirstOrDefault();
List<string> modelCsFiles = new List<string>();
if (cm != null)
{
string modelDir = Path.GetDirectoryName(ttFile);
modelCsFiles = cm.Descendants(edmNS + "EntitySet").Select(x => x.Attribute("EntityType").Value)
.Where(f => !string.IsNullOrEmpty(f))
.Select(f => Path.Combine(modelDir, f.Split('.').Last() + ".cs"))
.Where(f => File.Exists(Path.Combine(_projectPathCapitalized, edmxFile)))
.ToList();
}
modelCsFiles.ForEach(f => itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = f,
DependentUpon = Path.GetFileName(ttFile)
}));
remainingSourcesFiles.Remove(csModelFile);
remainingSourcesFiles.RemoveAll(f => modelCsFiles.Contains(f));
remainingNoneFiles.Remove(ttFile);
}
string contextttFile = fileAssociation.GetFilenameWithExtension(".context.tt");
if (contextttFile != null)
{
string csModelFile = fileAssociation.GetFilenameWithExtension(".context.cs");
Trace.Assert(csModelFile != null);
itemGroups.Nones.Add(new ItemGroups.None
{
Include = contextttFile,
Generator = "TextTemplatingFileGenerator",
DependentUpon = Path.GetFileName(edmxFile),
LastGenOutput = Path.GetFileName(csModelFile)
});
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = csModelFile,
AutoGen = true,
DesignTime = true,
DependentUpon = Path.GetFileName(contextttFile)
});
remainingNoneFiles.Remove(contextttFile);
remainingSourcesFiles.Remove(csModelFile);
}
break;
}
case FileAssociationType.Asax:
{
string linkedCsFile = fileAssociation.GetFilenameWithExtension(".asax.cs");
string asax = fileAssociation.GetFilenameWithExtension(".asax");
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = linkedCsFile,
DependentUpon = Path.GetFileName(asax),
LinkFolder = GetProjectLinkedFolder(linkedCsFile, _projectPathCapitalized, project)
});
itemGroups.Contents.Add(new ItemGroups.Content
{
Include = asax,
});
remainingSourcesFiles.Remove(asax);
remainingSourcesFiles.Remove(linkedCsFile);
break;
}
case FileAssociationType.XSD:
{
string xsdFile = fileAssociation.GetFilenameWithExtension(".xsd");
string xsxFile = fileAssociation.GetFilenameWithExtension(".xsx");
if (xsxFile != null)
{
itemGroups.Nones.Add(new ItemGroups.None()
{
Include = xsdFile
});
itemGroups.Nones.Add(new ItemGroups.None()
{
Include = xsxFile,
DependentUpon = xsdFile
});
remainingNoneFiles.Remove(xsxFile);
}
else
{
string designerFile = fileAssociation.GetFilenameWithExtension(".designer.cs");
string csFile = fileAssociation.GetFilenameWithExtension(".cs");
string xscFile = fileAssociation.GetFilenameWithExtension(".xsc");
string xssFile = fileAssociation.GetFilenameWithExtension(".xss");
itemGroups.Nones.Add(new ItemGroups.None()
{
Include = xsdFile,
Generator = "MSDataSetGenerator",
LastGenOutput = designerFile
});
itemGroups.Nones.Add(new ItemGroups.None()
{
Include = xscFile,
DependentUpon = xsdFile
});
itemGroups.Nones.Add(new ItemGroups.None()
{
Include = xssFile,
DependentUpon = xsdFile
});
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = designerFile,
DependentUpon = xsdFile,
AutoGen = true,
DesignTime = true
});
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = csFile,
DependentUpon = xsdFile
});
remainingSourcesFiles.Remove(designerFile);
remainingSourcesFiles.Remove(csFile);
remainingNoneFiles.Remove(xscFile);
remainingNoneFiles.Remove(xssFile);
}
remainingNoneFiles.Remove(xsdFile);
break;
}
default:
{
throw new ArgumentException(string.Format("Unsupported fileassociation type {0}", fileAssociation.Type));
}
}
}
#endregion
CsProjSubTypesInfos csProjSubTypesInfos = DetermineWindowsFormsSubTypes(configurations, remainingSourcesFiles);
if (csProjSubTypesInfos?.SubTypeInfos.Count > 0)
{
AllCsProjSubTypesInfos.Add(csProjSubTypesInfos);
}
#region remaining files
//tt files
List<string> ttFiles = remainingNoneFiles.Where(f => f.EndsWith(TTExtension, StringComparison.OrdinalIgnoreCase)).ToList();
foreach (string ttFile in ttFiles)
{
bool runtimeTemplate = project.AdditionalRuntimeTemplates.Contains(ttFile);
string expectedExtension =
runtimeTemplate ? ".cs" :
Util.GetTextTemplateDirectiveParam(Path.Combine(_projectPath, ttFile), "output", "extension") ?? ".cs";
if (!expectedExtension.StartsWith(".", StringComparison.Ordinal))
expectedExtension = "." + expectedExtension;
string fileNameWithoutExtension = ttFile.Substring(0, ttFile.Length - TTExtension.Length);
string generatedFile = fileNameWithoutExtension + expectedExtension;
string generator = runtimeTemplate
? "TextTemplatingFilePreprocessor"
: "TextTemplatingFileGenerator";
// Always include files generated by text templating (.tt), even if they don't exist yet.
// These files are expected to be absent during a clean build, as they are generated
// during the build process. Therefore, they cannot be left out of the csproj file.
AddContentGeneratedItem(itemGroups, ttFile, generatedFile, generator, false, _projectPathCapitalized, project);
remainingNoneFiles.Remove(ttFile);
//Remove generated file wherever it is.
remainingEmbeddedResourcesFiles.Remove(generatedFile);
remainingResourcesFiles.Remove(generatedFile);
remainingSourcesFiles.Remove(generatedFile);
remainingNoneFiles.Remove(generatedFile);
resolvedNoneFilesAddIfNewer.Remove(generatedFile);
}
//xaml files
var xamlFiles = remainingSourcesFiles.Where(src => src.EndsWith(".xaml", StringComparison.OrdinalIgnoreCase)).ToList();//tolist to enable removal in the foreach
foreach (var xaml in xamlFiles)
{
//single XamlFile
itemGroups.Pages.Add(new ItemGroups.Page
{
Include = xaml,
IsApplicationDefinition = project.ApplicationDefinitionFilenames.Any(f => f.Equals(xaml, StringComparison.OrdinalIgnoreCase)),
LinkFolder = GetProjectLinkedFolder(xaml, _projectPathCapitalized, project)
});
remainingSourcesFiles.Remove(xaml);
}
foreach (var file in remainingNoneFiles)
{
itemGroups.Nones.Add(new ItemGroups.None { Include = file, LinkFolder = project.GetLinkFolder(file) });
// Removing from remainingSourceFiles because sometimes the file is in both list. Could happen for example if
// NoneExtensions contains .sharpmake.cs and SourceFilesExtensions contains .cs
// If we don't remove the file, it will be duplicated in the csproj in a <Compile> section and in a <None> section.
remainingSourcesFiles.Remove(file);
}
foreach (var remainingSourcesFile in remainingSourcesFiles)
{
itemGroups.Compiles.Add(new ItemGroups.Compile
{
Include = remainingSourcesFile,
SubType = csProjSubTypesInfos?.SubTypeInfos.Find(s => string.Equals(s.FileName, remainingSourcesFile))?.SubType,
LinkFolder = GetProjectLinkedFolder(remainingSourcesFile, _projectPathCapitalized, project)
});
}
//resources
foreach (var file in remainingResourcesFiles)
{
// Have also as Resource for WPF
if (project.IncludeResxAsResources || !file.EndsWith(".resx", StringComparison.OrdinalIgnoreCase))
{
itemGroups.Resources.Add(new ItemGroups.Resource
{
Include = file,
LinkFolder = GetProjectLinkedFolder(file, _projectPathCapitalized, project)
});
}
}
foreach (var file in remainingEmbeddedResourcesFiles)
{
itemGroups.EmbeddedResources.Add(new ItemGroups.EmbeddedResource
{
Include = file,
MergeWithCto = file.Equals("VSPackage.resx", StringComparison.OrdinalIgnoreCase) ? "true" : null,
LinkFolder = project.GetLinkFolder(file)
});
}
foreach (var file in resolvedNoneFilesAddIfNewer)
{
itemGroups.Nones.Add(new ItemGroups.None { Include = file, CopyToOutputDirectory = CopyToOutputDirectory.PreserveNewest, LinkFolder = project.GetLinkFolder(file) });
}
#endregion
#region References
foreach (var conf in configurations)
{
var dotNetFramework = conf.Target.GetFragment<DotNetFramework>();
if (dotNetFramework.IsDotNetFramework())
{
foreach (var str in conf.ReferencesByName)
{
var referencesByName = new ItemGroups.Reference
{
Include = str,
Private = project.DependenciesCopyLocal.HasFlag(Project.DependenciesCopyLocalTypes.DotNetReferences) ? default(bool?) : false,
};
itemGroups.AddReference(GetTargetFramework(conf), referencesByName);
}
}
}
foreach (var conf in configurations)
{
var dotNetFramework = conf.Target.GetFragment<DotNetFramework>();
foreach (var str in conf.ReferencesByNameExternal)
{
var referencesByNameExternal = new ItemGroups.Reference
{
Include = str,
Private = project.DependenciesCopyLocal.HasFlag(Project.DependenciesCopyLocalTypes.DotNetExtensions),
};
itemGroups.AddReference(GetTargetFramework(conf), referencesByNameExternal);
}
}
foreach (var conf in configurations)
{
var dotNetFramework = conf.Target.GetFragment<DotNetFramework>();
foreach (var str in conf.ReferencesByPath.Select(Util.GetCapitalizedPath))
{
var referencesByPath = new ItemGroups.Reference
{
Include = Path.GetFileNameWithoutExtension(str),
SpecificVersion = false,
HintPath = Util.PathGetRelative(_projectPathCapitalized, str),
Private = project.DependenciesCopyLocal.HasFlag(Project.DependenciesCopyLocalTypes.ExternalReferences),
};
itemGroups.AddReference(GetTargetFramework(conf), referencesByPath);
}
foreach (var str in project.AdditionalEmbeddedAssemblies.Select(Util.GetCapitalizedPath))
{
var referencesByPath = new ItemGroups.Reference
{
Include = Path.GetFileNameWithoutExtension(str),
SpecificVersion = false,
HintPath = Util.PathGetRelative(_projectPathCapitalized, str),
Private = false
};
itemGroups.AddReference(GetTargetFramework(conf), referencesByPath);
}
}
foreach (var conf in configurations)
{
var dotNetFramework = conf.Target.GetFragment<DotNetFramework>();
if (dotNetFramework.IsDotNetFramework())
{
foreach (var r in conf.DotNetReferences)
{
var references = GetItemGroupsReference(r, project.DependenciesCopyLocal);
itemGroups.AddReference(GetTargetFramework(conf), references);
}
}
}
if (Util.DirectoryExists(Path.Combine(project.SourceRootPath, "Web References")))
itemGroups.WebReferences.Add(new ItemGroups.WebReference { Include = @"Web References\" });
itemGroups.WebReferences.AddRange(
project.WebReferences.Select(str => new ItemGroups.WebReference { Include = str }));
itemGroups.FolderIncludes.AddRange(project.AdditionalFolders.Select(str => new ItemGroups.FolderInclude { Include = str }));
foreach (var url in project.WebReferenceUrls)
{
itemGroups.WebReferenceUrls.Add(
new ItemGroups.WebReferenceUrl
{
Include = url.Name,
UrlBehavior = url.UrlBehavior,
RelPath = url.RelPath,
UpdateFromURL = url.UpdateFromURL,
ServiceLocationURL = url.ServiceLocationURL,
CachedDynamicPropName = url.CachedDynamicPropName,
CachedAppSettingsObjectName = url.CachedAppSettingsObjectName,
CachedSettingsPropName = url.CachedSettingsPropName
});
}
bool propagationFlag = project.DependenciesCopyLocal.HasFlag(Project.DependenciesCopyLocalTypes.ExternalReferences);
foreach (var comRef in project.ComReferences)
{
bool? privateValue = comRef.Private;
if (!privateValue.HasValue && propagationFlag)
{
// Only use the project propagation flag is not explicit value was provided and if the project propagation flag is set.
privateValue = propagationFlag;
}
itemGroups.ComReferences.Add(
new ItemGroups.ComReference
{
Include = comRef.Name,
Guid = comRef.Guid,
VersionMajor = comRef.VersionMajor,
VersionMinor = comRef.VersionMinor,
Lcid = comRef.Lcid,
WrapperTool = comRef.WrapperTool.ToString(),
Private = privateValue,
EmbedInteropTypes = comRef.EmbedInteropTypes,
});
}
GeneratePackageReferences(project, configurations, itemGroups, generatedFiles, skipFiles);
foreach (var configuration in configurations)
{
var tf = GetTargetFramework(configuration);
foreach (var frameworkReference in configuration.FrameworkReferences)
{
itemGroups.AddFrameworkReference(new ItemGroups.FrameworkReference { Include = frameworkReference },
tf);
}
}
itemGroups.Services.AddRange(project.Services.Select(s => new ItemGroups.Service { Include = s }));
itemGroups.BootstrapperPackages.AddRange(project.BootstrapperPackages.Select(
b =>
new ItemGroups.BootstrapperPackage()
{
Include = b.Include,
Install = b.Install,
ProductName = b.ProductName,
Visible = b.Visible,
}
));
itemGroups.FileAssociationItems.AddRange(project.FileAssociationItems.Select(
b =>
new ItemGroups.FileAssociationItem()
{
Include = b.Include,
Visible = b.Visible,
Description = b.Description,
Progid = b.Progid,
DefaultIcon = b.DefaultIcon
}
));
itemGroups.PublishFiles.AddRange(project.PublishFiles.Select(
b =>
new ItemGroups.PublishFile()
{
Include = b.Include,
Visible = b.Visible,
Group = b.Group,
PublishState = b.PublishState,
IncludeHash = b.IncludeHash,
FileType = b.FileType
}
));
#endregion
}