/// <summary>
/// Add or rename an entry in the cache.
/// Old full path may be null iff it was not already in the cache.
/// </summary>
/// <remarks>
/// Must be called within the cache lock.
/// </remarks>
private void RenameEntryInternal(string oldFullPathIfAny, ProjectRootElement projectRootElement)
{
ErrorUtilities.VerifyThrowInternalNull(projectRootElement.FullPath, "FullPath");
if (oldFullPathIfAny != null)
{
ErrorUtilities.VerifyThrowInternalRooted(oldFullPathIfAny);
ErrorUtilities.VerifyThrow(_weakCache[oldFullPathIfAny] == projectRootElement, "Should already be present");
_weakCache.Remove(oldFullPathIfAny);
}
// There may already be a ProjectRootElement in the cache with the new name. In this case we cannot throw an exception;
// we must merely replace it. This is because it may be an unrooted entry
// (and thus gone from the client's point of view) that merely remains
// in the cache because we still have a reference to it from our strong cache.
// Another possibility is that there are two, unrelated, un-saved, in-memory projects that were given the same path.
// Replacing the cache entry does not in itself cause a problem -- if there are any actual users of the old
// entry they will not be affected. There would then exist more than one ProjectRootElement with the same path,
// but clients ought not get themselves into such a state - and unless they save them to disk,
// it may not be a problem. Replacing also doesn't cause a problem for the strong cache,
// as it is never consulted by us, but it is reasonable for us to remove the old entry in that case.
ProjectRootElement existingWeakEntry;
_weakCache.TryGetValue(projectRootElement.FullPath, out existingWeakEntry);
if (existingWeakEntry != null && !Object.ReferenceEquals(existingWeakEntry, projectRootElement))
{
_strongCache.Remove(existingWeakEntry);
RaiseProjectRootElementRemovedFromStrongCache(existingWeakEntry);
}
DebugTraceCache("Adding: ", projectRootElement.FullPath);
_weakCache[projectRootElement.FullPath] = projectRootElement;
BoostEntryInStrongCache(projectRootElement);
}
/// <summary>
/// Cleanse the project name, by replacing characters like '@', '$' with '_'
/// </summary>
/// <param name="projectName">The name to be cleansed</param>
/// <returns>string</returns>
private static string CleanseProjectName(string projectName)
{
ErrorUtilities.VerifyThrow(projectName != null, "Null strings not allowed.");
// If there are no special chars, just return the original string immediately.
// Don't even instantiate the StringBuilder.
int indexOfChar = projectName.IndexOfAny(s_charsToCleanse);
if (indexOfChar == -1)
{
return(projectName);
}
// This is where we're going to work on the final string to return to the caller.
var cleanProjectName = new StringBuilder(projectName);
// Replace each unclean character with a clean one
foreach (char uncleanChar in s_charsToCleanse)
{
cleanProjectName.Replace(uncleanChar, cleanCharacter);
}
return(cleanProjectName.ToString());
}
/// <summary>
/// Returns an existing ProjectRootElement for the specified file path, if any.
/// If none exists, calls the provided delegate to load one, and adds that to the cache.
/// The reason that it calls back to do this is so that the cache is locked between determining
/// that the entry does not exist and adding the entry.
///
/// If <see cref="_autoReloadFromDisk"/> was set to true, and the file on disk has changed since it was cached,
/// it will be reloaded before being returned.
///
/// Thread safe.
/// </summary>
/// <remarks>
/// Never needs to consult the strong cache as well, since if the item is in there, it will
/// not have left the weak cache.
/// If item is found, boosts it to the top of the strong cache.
/// </remarks>
/// <param name="projectFile">The project file which contains the ProjectRootElement. Must be a full path.</param>
/// <param name="openProjectRootElement">The delegate to use to load if necessary. May be null.</param>
/// <param name="isExplicitlyLoaded"><code>true</code> if the project is explicitly loaded, otherwise <code>false</code>.</param>
/// <param name="preserveFormatting"><code>true</code> to the project was loaded with the formated preserved, otherwise <code>false</code>.</param>
/// <returns>The ProjectRootElement instance if one exists. Null otherwise.</returns>
internal override ProjectRootElement Get(string projectFile, OpenProjectRootElement openProjectRootElement, bool isExplicitlyLoaded,
bool?preserveFormatting)
{
// Should already have been canonicalized
ErrorUtilities.VerifyThrowInternalRooted(projectFile);
lock (_locker)
{
ProjectRootElement projectRootElement;
_weakCache.TryGetValue(projectFile, out projectRootElement);
if (preserveFormatting != null && projectRootElement != null && projectRootElement.XmlDocument.PreserveWhitespace != preserveFormatting)
{
// Cached project doesn't match preserveFormatting setting, so reload it
projectRootElement.Reload(true, preserveFormatting);
}
if (projectRootElement != null && _autoReloadFromDisk)
{
FileInfo fileInfo = FileUtilities.GetFileInfoNoThrow(projectFile);
// If the file doesn't exist on disk, go ahead and use the cached version.
// It's an in-memory project that hasn't been saved yet.
if (fileInfo != null)
{
bool forgetEntry = false;
if (fileInfo.LastWriteTime != projectRootElement.LastWriteTimeWhenRead)
{
// File was changed on disk by external means. Cached version is no longer reliable.
// We could throw here or ignore the problem, but it is a common and reasonable pattern to change a file
// externally and load a new project over it to see the new content. So we dump it from the cache
// to force a load from disk. There might then exist more than one ProjectRootElement with the same path,
// but clients ought not get themselves into such a state - and unless they save them to disk,
// it may not be a problem.
forgetEntry = true;
}
else if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("MSBUILDCACHECHECKFILECONTENT")))
{
// QA tests run too fast for the timestamp check to work. This environment variable is for their
// use: it checks the file content as well as the timestamp. That's better than completely disabling
// the cache as we get test coverage of the rest of the cache code.
XmlDocument document = new XmlDocument();
document.PreserveWhitespace = projectRootElement.XmlDocument.PreserveWhitespace;
using (var xtr = XmlReaderExtension.Create(projectRootElement.FullPath, projectRootElement.ProjectRootElementCache.LoadProjectsReadOnly))
{
document.Load(xtr.Reader);
}
string diskContent = document.OuterXml;
string cacheContent = projectRootElement.XmlDocument.OuterXml;
if (diskContent != cacheContent)
{
forgetEntry = true;
}
}
if (forgetEntry)
{
ForgetEntry(projectRootElement);
DebugTraceCache("Out of date dropped from XML cache: ", projectFile);
projectRootElement = null;
}
}
}
if (projectRootElement == null && openProjectRootElement != null)
{
projectRootElement = openProjectRootElement(projectFile, this);
ErrorUtilities.VerifyThrowInternalNull(projectRootElement, "projectRootElement");
ErrorUtilities.VerifyThrow(projectRootElement.FullPath == projectFile, "Got project back with incorrect path");
ErrorUtilities.VerifyThrow(_weakCache.Contains(projectFile), "Open should have renamed into cache and boosted");
}
else if (projectRootElement != null)
{
DebugTraceCache("Satisfied from XML cache: ", projectFile);
BoostEntryInStrongCache(projectRootElement);
}
// An implicit load will never reset the explicit flag.
if (projectRootElement != null && isExplicitlyLoaded)
{
projectRootElement.MarkAsExplicitlyLoaded();
}
return(projectRootElement);
}
}
/// <summary>
/// Given two MSBuildArchitecture values, returns the concrete result of merging the two. If the merge fails, the merged architecture
/// string is returned null, and the return value of the method is false. Otherwise, if the merge succeeds, the method returns
/// true with the merged architecture value. E.g.:
/// "x86" + "x64" = null (false)
/// "x86" + "don't care" = "x86" (true)
/// "current architecture" + "x86" = "x86" (true) on a 32-bit process, and null (false) on a 64-bit process
/// "current architecture" + "don't care" = "x86" (true) on a 32-bit process, and "x64" (true) on a 64-bit process
/// A null or empty string is interpreted as "don't care".
/// If both specify "don't care", then defaults to whatever the current process architecture is.
/// </summary>
internal static bool TryMergeArchitectureValues(string architectureA, string architectureB, out string mergedArchitecture)
{
ErrorUtilities.VerifyThrow(architectureA != String.Empty && architectureB != String.Empty, "We should never get an empty string passed to this method");
// set up the defaults
if (architectureA == null)
{
architectureA = MSBuildArchitectureValues.any;
}
if (architectureB == null)
{
architectureB = MSBuildArchitectureValues.any;
}
string currentArchitecture = GetCurrentMSBuildArchitecture();
// if they're equal, then there's no problem -- just return the equivalent runtime.
if (architectureA.Equals(architectureB, StringComparison.OrdinalIgnoreCase))
{
if (architectureA.Equals(MSBuildArchitectureValues.currentArchitecture, StringComparison.OrdinalIgnoreCase) ||
architectureA.Equals(MSBuildArchitectureValues.any, StringComparison.OrdinalIgnoreCase))
{
mergedArchitecture = currentArchitecture;
}
else
{
mergedArchitecture = architectureA;
}
return(true);
}
// if both A and B are one of CLR4, don't care, or current, then the end result will be CLR4 no matter what.
if (
(
architectureA.Equals(currentArchitecture, StringComparison.OrdinalIgnoreCase) ||
architectureA.Equals(MSBuildArchitectureValues.currentArchitecture, StringComparison.OrdinalIgnoreCase) ||
architectureA.Equals(MSBuildArchitectureValues.any, StringComparison.OrdinalIgnoreCase)
) &&
(
architectureB.Equals(currentArchitecture, StringComparison.OrdinalIgnoreCase) ||
architectureB.Equals(MSBuildArchitectureValues.currentArchitecture, StringComparison.OrdinalIgnoreCase) ||
architectureB.Equals(MSBuildArchitectureValues.any, StringComparison.OrdinalIgnoreCase)
)
)
{
mergedArchitecture = currentArchitecture;
return(true);
}
// If A doesn't care, then it's B -- and we can say B straight out, because if B were one of the
// special cases (current runtime or don't care) then it would already have been caught in the
// previous clause.
if (architectureA.Equals(MSBuildArchitectureValues.any, StringComparison.OrdinalIgnoreCase))
{
mergedArchitecture = architectureB;
return(true);
}
// And vice versa
if (architectureB.Equals(MSBuildArchitectureValues.any, StringComparison.OrdinalIgnoreCase))
{
mergedArchitecture = architectureA;
return(true);
}
// and now we've run out of things that it could be -- all the remaining options are non-matches.
mergedArchitecture = null;
return(false);
}
