/// <summary>
/// Add a PropertyGroup to the project for a particular Asp.Net configuration. This PropertyGroup
/// will have the correct values for all the Asp.Net properties for this project and this configuration.
/// </summary>
private void AddPropertyGroupForAspNetConfiguration
(
ProjectInstance traversalProject,
ProjectInstance metaprojectInstance,
ProjectInSolution project,
string configurationName,
AspNetCompilerParameters aspNetCompilerParameters,
string solutionFile
)
{
// If the configuration doesn't match, don't add the properties.
if (!traversalProject.EvaluateCondition(String.Format(CultureInfo.InvariantCulture, " '$(AspNetConfiguration)' == '{0}' ", EscapingUtilities.Escape(configurationName))))
{
return;
}
// Add properties into the property group for each of the AspNetCompiler properties.
// REVIEW: SetProperty takes an evaluated value. Are we doing the right thing here?
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetVirtualPath"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetVirtualPath));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetPhysicalPath"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetPhysicalPath));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetTargetPath"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetTargetPath));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetForce"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetForce));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetUpdateable"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetUpdateable));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetDebug"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetDebug));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetKeyFile"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetKeyFile));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetKeyContainer"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetKeyContainer));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetDelaySign"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetDelaySign));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetAPTCA"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetAPTCA));
metaprojectInstance.SetProperty(GenerateSafePropertyName(project, "AspNetFixedNames"), EscapingUtilities.Escape(aspNetCompilerParameters.aspNetFixedNames));
string aspNetPhysicalPath = aspNetCompilerParameters.aspNetPhysicalPath;
if (!String.IsNullOrEmpty(aspNetPhysicalPath))
{
// Trim the trailing slash if one exists.
if (
(aspNetPhysicalPath[aspNetPhysicalPath.Length - 1] == Path.AltDirectorySeparatorChar) ||
(aspNetPhysicalPath[aspNetPhysicalPath.Length - 1] == Path.DirectorySeparatorChar)
)
{
aspNetPhysicalPath = aspNetPhysicalPath.Substring(0, aspNetPhysicalPath.Length - 1);
}
// This gets us the last folder in the physical path.
string lastFolderInPhysicalPath = null;
try
{
lastFolderInPhysicalPath = Path.GetFileName(aspNetPhysicalPath);
}
catch (Exception e)
{
if (ExceptionHandling.NotExpectedException(e))
{
throw;
}
ProjectFileErrorUtilities.VerifyThrowInvalidProjectFile
(
false,
"SubCategoryForSolutionParsingErrors",
new BuildEventFileInfo(solutionFile),
e,
"SolutionParseInvalidProjectFileName",
project.RelativePath,
e.Message
);
}
if (!String.IsNullOrEmpty(lastFolderInPhysicalPath))
{
// If there is a global property called "OutDir" set, that means the caller is trying to
// override the AspNetTargetPath. What we want to do in this case is concatenate:
// $(OutDir) + "\_PublishedWebsites" + (the last portion of the folder in the AspNetPhysicalPath).
if (traversalProject.EvaluateCondition(" '$(OutDir)' != '' "))
{
string outDirValue = String.Empty;
ProjectPropertyInstance outdir = metaprojectInstance.GetProperty("OutDir");
if (outdir != null)
{
outDirValue = ProjectInstance.GetPropertyValueEscaped(outdir);
}
// Make sure the path we are appending to has no leading slash to prevent double slashes.
string publishWebsitePath = EscapingUtilities.Escape(WebProjectOverrideFolder) + Path.DirectorySeparatorChar + EscapingUtilities.Escape(lastFolderInPhysicalPath) + Path.DirectorySeparatorChar;
metaprojectInstance.SetProperty
(
GenerateSafePropertyName(project, "AspNetTargetPath"),
outDirValue + publishWebsitePath
);
}
}
}
}
private void ParseAspNetCompilerProperty(ProjectInSolution proj, string propertyName, string propertyValue)
{
int length = propertyName.IndexOf('.');
if (length != -1)
{
string str1 = propertyName.Substring(0, length);
string str2 = propertyName.Length - length > 0 ? propertyName.Substring(length + 1, propertyName.Length - length - 1) : "";
propertyValue = this.TrimQuotes(propertyValue);
object obj = proj.AspNetConfigurations[(object)str1];
AspNetCompilerParameters compilerParameters;
if (obj == null)
{
compilerParameters = new AspNetCompilerParameters();
compilerParameters.aspNetVirtualPath = string.Empty;
compilerParameters.aspNetPhysicalPath = string.Empty;
compilerParameters.aspNetTargetPath = string.Empty;
compilerParameters.aspNetForce = string.Empty;
compilerParameters.aspNetUpdateable = string.Empty;
compilerParameters.aspNetDebug = string.Empty;
compilerParameters.aspNetKeyFile = string.Empty;
compilerParameters.aspNetKeyContainer = string.Empty;
compilerParameters.aspNetDelaySign = string.Empty;
compilerParameters.aspNetAPTCA = string.Empty;
compilerParameters.aspNetFixedNames = string.Empty;
}
else
{
compilerParameters = (AspNetCompilerParameters)obj;
}
if (str2 == "AspNetCompiler.VirtualPath")
{
compilerParameters.aspNetVirtualPath = propertyValue;
}
else if (str2 == "AspNetCompiler.PhysicalPath")
{
compilerParameters.aspNetPhysicalPath = propertyValue;
}
else if (str2 == "AspNetCompiler.TargetPath")
{
compilerParameters.aspNetTargetPath = propertyValue;
}
else if (str2 == "AspNetCompiler.ForceOverwrite")
{
compilerParameters.aspNetForce = propertyValue;
}
else if (str2 == "AspNetCompiler.Updateable")
{
compilerParameters.aspNetUpdateable = propertyValue;
}
else if (str2 == "AspNetCompiler.Debug")
{
compilerParameters.aspNetDebug = propertyValue;
}
else if (str2 == "AspNetCompiler.KeyFile")
{
compilerParameters.aspNetKeyFile = propertyValue;
}
else if (str2 == "AspNetCompiler.KeyContainer")
{
compilerParameters.aspNetKeyContainer = propertyValue;
}
else if (str2 == "AspNetCompiler.DelaySign")
{
compilerParameters.aspNetDelaySign = propertyValue;
}
else if (str2 == "AspNetCompiler.AllowPartiallyTrustedCallers")
{
compilerParameters.aspNetAPTCA = propertyValue;
}
else if (str2 == "AspNetCompiler.FixedNames")
{
compilerParameters.aspNetFixedNames = propertyValue;
}
proj.AspNetConfigurations[(object)str1] = (object)compilerParameters;
}
else if (string.Compare(propertyName, "ProjectReferences", StringComparison.OrdinalIgnoreCase) == 0)
{
string str1 = propertyValue;
char[] separator = new char[1];
int index = 0;
int num1 = 59;
separator[index] = (char)num1;
int num2 = 1;
foreach (string str2 in str1.Split(separator, (StringSplitOptions)num2))
{
if (str2.IndexOf('|') != -1)
{
int startIndex = str2.IndexOf('{');
if (startIndex != -1)
{
int num3 = str2.IndexOf('}', startIndex);
if (num3 != -1)
{
string str3 = str2.Substring(startIndex, num3 - startIndex + 1);
proj.Dependencies.Add((object)str3);
proj.ProjectReferences.Add((object)str3);
}
}
}
}
}
else
{
if (string.Compare(propertyName, "TargetFrameworkMoniker", StringComparison.OrdinalIgnoreCase) != 0)
{
return;
}
string escapedString = this.TrimQuotes(propertyValue);
proj.TargetFrameworkMoniker = (escapedString);
}
}
/// <summary>
/// Takes a property name / value that comes from the SLN file for a Venus project, and
/// stores it appropriately in our data structures.
/// </summary>
/// <param name="proj"></param>
/// <param name="propertyName"></param>
/// <param name="propertyValue"></param>
private void ParseAspNetCompilerProperty
(
ProjectInSolution proj,
string propertyName,
string propertyValue
)
{
// What we expect to find in the SLN file is something that looks like this:
//
// Project("{E24C65DC-7377-472B-9ABA-BC803B73C61A}") = "c:\...\myfirstwebsite\", "..\..\..\..\..\..\rajeev\temp\websites\myfirstwebsite", "{956CC04E-FD59-49A9-9099-96888CB6F366}"
// ProjectSection(WebsiteProperties) = preProject
// TargetFrameworkMoniker = ".NETFramework,Version%3Dv4.0"
// ProjectReferences = "{FD705688-88D1-4C22-9BFF-86235D89C2FC}|CSClassLibrary1.dll;{F0726D09-042B-4A7A-8A01-6BED2422BD5D}|VCClassLibrary1.dll;"
// Debug.AspNetCompiler.VirtualPath = "/publishfirst"
// Debug.AspNetCompiler.PhysicalPath = "..\..\..\..\..\..\rajeev\temp\websites\myfirstwebsite\"
// Debug.AspNetCompiler.TargetPath = "..\..\..\..\..\..\rajeev\temp\publishfirst\"
// Debug.AspNetCompiler.ForceOverwrite = "true"
// Debug.AspNetCompiler.Updateable = "true"
// Debug.AspNetCompiler.Enabled = "true"
// Debug.AspNetCompiler.Debug = "true"
// Debug.AspNetCompiler.KeyFile = ""
// Debug.AspNetCompiler.KeyContainer = ""
// Debug.AspNetCompiler.DelaySign = "true"
// Debug.AspNetCompiler.AllowPartiallyTrustedCallers = "true"
// Debug.AspNetCompiler.FixedNames = "true"
// Release.AspNetCompiler.VirtualPath = "/publishfirst"
// Release.AspNetCompiler.PhysicalPath = "..\..\..\..\..\..\rajeev\temp\websites\myfirstwebsite\"
// Release.AspNetCompiler.TargetPath = "..\..\..\..\..\..\rajeev\temp\publishfirst\"
// Release.AspNetCompiler.ForceOverwrite = "true"
// Release.AspNetCompiler.Updateable = "true"
// Release.AspNetCompiler.Enabled = "true"
// Release.AspNetCompiler.Debug = "false"
// Release.AspNetCompiler.KeyFile = ""
// Release.AspNetCompiler.KeyContainer = ""
// Release.AspNetCompiler.DelaySign = "true"
// Release.AspNetCompiler.AllowPartiallyTrustedCallers = "true"
// Release.AspNetCompiler.FixedNames = "true"
// EndProjectSection
// EndProject
//
// This method is responsible for parsing each of the lines within the "WebsiteProperties" section.
// The first component of each property name is actually the configuration for which that
// property applies.
int indexOfFirstDot = propertyName.IndexOf('.');
if (indexOfFirstDot != -1)
{
// The portion before the first dot is the configuration name.
string configurationName = propertyName.Substring(0, indexOfFirstDot);
// The rest of it is the actual property name.
string aspNetPropertyName = ((propertyName.Length - indexOfFirstDot) > 0) ? propertyName.Substring(indexOfFirstDot + 1, propertyName.Length - indexOfFirstDot - 1) : "";
// And the part after the <equals> sign is the property value (which was parsed out for us prior
// to calling this method).
propertyValue = TrimQuotes(propertyValue);
// Grab the parameters for this specific configuration if they exist.
object aspNetCompilerParametersObject = proj.AspNetConfigurations[configurationName];
AspNetCompilerParameters aspNetCompilerParameters;
if (aspNetCompilerParametersObject == null)
{
// If it didn't exist, create a new one.
aspNetCompilerParameters = new AspNetCompilerParameters();
aspNetCompilerParameters.aspNetVirtualPath = String.Empty;
aspNetCompilerParameters.aspNetPhysicalPath = String.Empty;
aspNetCompilerParameters.aspNetTargetPath = String.Empty;
aspNetCompilerParameters.aspNetForce = String.Empty;
aspNetCompilerParameters.aspNetUpdateable = String.Empty;
aspNetCompilerParameters.aspNetDebug = String.Empty;
aspNetCompilerParameters.aspNetKeyFile = String.Empty;
aspNetCompilerParameters.aspNetKeyContainer = String.Empty;
aspNetCompilerParameters.aspNetDelaySign = String.Empty;
aspNetCompilerParameters.aspNetAPTCA = String.Empty;
aspNetCompilerParameters.aspNetFixedNames = String.Empty;
}
else
{
// Otherwise just unbox it.
aspNetCompilerParameters = (AspNetCompilerParameters)aspNetCompilerParametersObject;
}
// Update the appropriate field within the parameters struct.
if (aspNetPropertyName == "AspNetCompiler.VirtualPath")
{
aspNetCompilerParameters.aspNetVirtualPath = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.PhysicalPath")
{
aspNetCompilerParameters.aspNetPhysicalPath = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.TargetPath")
{
aspNetCompilerParameters.aspNetTargetPath = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.ForceOverwrite")
{
aspNetCompilerParameters.aspNetForce = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.Updateable")
{
aspNetCompilerParameters.aspNetUpdateable = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.Debug")
{
aspNetCompilerParameters.aspNetDebug = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.KeyFile")
{
aspNetCompilerParameters.aspNetKeyFile = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.KeyContainer")
{
aspNetCompilerParameters.aspNetKeyContainer = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.DelaySign")
{
aspNetCompilerParameters.aspNetDelaySign = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.AllowPartiallyTrustedCallers")
{
aspNetCompilerParameters.aspNetAPTCA = propertyValue;
}
else if (aspNetPropertyName == "AspNetCompiler.FixedNames")
{
aspNetCompilerParameters.aspNetFixedNames = propertyValue;
}
// Store the updated parameters struct back into the hashtable by configuration name.
proj.AspNetConfigurations[configurationName] = aspNetCompilerParameters;
}
else
{
// ProjectReferences = "{FD705688-88D1-4C22-9BFF-86235D89C2FC}|CSClassLibrary1.dll;{F0726D09-042B-4A7A-8A01-6BED2422BD5D}|VCClassLibrary1.dll;"
if (string.Compare(propertyName, "ProjectReferences", StringComparison.OrdinalIgnoreCase) == 0)
{
string[] projectReferenceEntries = propertyValue.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string projectReferenceEntry in projectReferenceEntries)
{
int indexOfBar = projectReferenceEntry.IndexOf('|');
// indexOfBar could be -1 if we had semicolons in the file names, so skip entries that
// don't contain a guid. File names may not contain the '|' character
if (indexOfBar != -1)
{
int indexOfOpeningBrace = projectReferenceEntry.IndexOf('{');
if (indexOfOpeningBrace != -1)
{
int indexOfClosingBrace = projectReferenceEntry.IndexOf('}', indexOfOpeningBrace);
if (indexOfClosingBrace != -1)
{
string referencedProjectGuid = projectReferenceEntry.Substring(indexOfOpeningBrace,
indexOfClosingBrace - indexOfOpeningBrace + 1);
proj.AddDependency(referencedProjectGuid);
proj.ProjectReferences.Add(referencedProjectGuid);
}
}
}
}
}
else if (String.Compare(propertyName, "TargetFrameworkMoniker", StringComparison.OrdinalIgnoreCase) == 0)
{
//Website project need to back support 3.5 msbuild parser for the Blend (it is not move to .Net4.0 yet.)
//However, 3.5 version of Solution parser can't handle a equal sign in the value.
//The "=" in targetframeworkMoniker was escaped to "%3D" for Orcas
string targetFrameworkMoniker = TrimQuotes(propertyValue);
proj.TargetFrameworkMoniker = Microsoft.Build.Shared.EscapingUtilities.UnescapeAll(targetFrameworkMoniker);
}
}
}