internal override BuildResult GetBuildResult(string cacheKey, VirtualPath virtualPath, long hashCode, bool ensureIsUpToDate)
{
Debug.Trace("BuildResultCache", "Looking for '" + cacheKey + "' in the memory cache");
string key = GetMemoryCacheKey(cacheKey);
BuildResult result = (BuildResult)_cache.Get(key);
// Not found in the cache
if (result == null)
{
Debug.Trace("BuildResultCache", "'" + cacheKey + "' was not found in the memory cache");
return(null);
}
// We found it in the cache, but is it up to date. First, if it uses a CacheDependency,
// it must be up to date (this is the default case when using MapPathBasedVirtualPathProvider).
// If not, then we need to explicitely check that it's up to date (more expensive)
if (!result.UsesCacheDependency && !result.IsUpToDate(virtualPath, ensureIsUpToDate))
{
Debug.Trace("BuildResultCache", "'" + cacheKey + "' was found but is out of date");
// Remove it from the cache
_cache.Remove(key);
Debug.Assert(_cache.Get(key) == null);
return(null);
}
Debug.Trace("BuildResultCache", "'" + cacheKey + "' was found in the memory cache");
// It's up to date: return it
return(result);
}
internal override BuildResult GetBuildResult(string cacheKey, VirtualPath virtualPath, long hashCode, bool ensureIsUpToDate)
{
string memoryCacheKey = GetMemoryCacheKey(cacheKey);
BuildResult result = (BuildResult)this._cache.Get(memoryCacheKey);
if (result == null)
{
return(null);
}
if (!result.UsesCacheDependency && !result.IsUpToDate(virtualPath, ensureIsUpToDate))
{
this._cache.Remove(memoryCacheKey);
return(null);
}
return(result);
}
private BuildResult ReadFileInternal(VirtualPath virtualPath, string preservationFile, long hashCode, bool ensureIsUpToDate)
{
XmlDocument document = new XmlDocument();
document.Load(preservationFile);
this._root = document.DocumentElement;
if ((this._root == null) || (this._root.Name != "preserve"))
{
return(null);
}
BuildResultTypeCode code = (BuildResultTypeCode)int.Parse(this.GetAttribute("resultType"), CultureInfo.InvariantCulture);
if (virtualPath == null)
{
virtualPath = VirtualPath.Create(this.GetAttribute("virtualPath"));
}
long num = 0L;
string str2 = null;
if (!this._precompilationMode)
{
string attribute = this.GetAttribute("hash");
if (attribute == null)
{
return(null);
}
num = long.Parse(attribute, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
str2 = this.GetAttribute("filehash");
}
BuildResult result = BuildResult.CreateBuildResultFromCode(code, virtualPath);
if (!this._precompilationMode)
{
this.ReadDependencies();
if (this._sourceDependencies != null)
{
result.SetVirtualPathDependencies(this._sourceDependencies);
}
result.VirtualPathDependenciesHash = str2;
bool flag = false;
if (!result.IsUpToDate(virtualPath, ensureIsUpToDate))
{
flag = true;
}
else
{
long num2 = result.ComputeHashCode(hashCode);
if ((num2 == 0L) || (num2 != num))
{
flag = true;
}
}
if (flag)
{
bool gotLock = false;
try
{
CompilationLock.GetLock(ref gotLock);
result.RemoveOutOfDateResources(this);
File.Delete(preservationFile);
}
finally
{
if (gotLock)
{
CompilationLock.ReleaseLock();
}
}
return(null);
}
}
result.GetPreservedAttributes(this);
return(result);
}
private BuildResult ReadFileInternal(VirtualPath virtualPath, string preservationFile, long hashCode, bool ensureIsUpToDate)
{
XmlDocument doc = new XmlDocument();
doc.Load(preservationFile);
// Get the root element, and make sure it's what we expect
_root = doc.DocumentElement;
Debug.Assert(_root != null && _root.Name == "preserve", "_root != null && _root.Name == \"preserve\"");
if (_root == null || _root.Name != "preserve")
{
return(null);
}
// Get the type of the BuildResult preserved in this file
string resultTypeCodeString = GetAttribute("resultType");
BuildResultTypeCode resultTypeCode = (BuildResultTypeCode)Int32.Parse(
resultTypeCodeString, CultureInfo.InvariantCulture);
// Get the config path that affects this BuildResult if one wasn't passed in.
// Note that the passed in path may be different with Sharepoint-like ghosting (VSWhidbey 343230)
if (virtualPath == null)
{
virtualPath = VirtualPath.Create(GetAttribute("virtualPath"));
}
long savedHash = 0;
string savedFileHash = null;
// Ignore dependencies in precompilation mode
if (!_precompilationMode)
{
// Read the saved hash from the preservation file
string hashString = GetAttribute("hash");
Debug.Assert(hashString != null, "hashString != null");
if (hashString == null)
{
return(null);
}
// Parse the saved hash string as an hex int
savedHash = Int64.Parse(hashString, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
// Read the saved file hash from the preservation file. This is the hash the represents
// the state of all the virtual files that the build result depends on.
savedFileHash = GetAttribute("filehash");
}
// Create the BuildResult accordingly
BuildResult result = BuildResult.CreateBuildResultFromCode(resultTypeCode, virtualPath);
// Ignore dependencies in precompilation mode
if (!_precompilationMode)
{
ReadDependencies();
if (_sourceDependencies != null)
{
result.SetVirtualPathDependencies(_sourceDependencies);
}
result.VirtualPathDependenciesHash = savedFileHash;
// Check if the build result is up to date
bool outOfDate = false;
if (!result.IsUpToDate(virtualPath, ensureIsUpToDate))
{
Debug.Trace("PreservationFileReader", Path.GetFileName(preservationFile) +
" is out of date (IsUpToDate==false)");
outOfDate = true;
}
else
{
// The virtual paths hash code was up to date, so check the
// other hash code.
// Get the current hash code
long currentHash = result.ComputeHashCode(hashCode);
// If the hash doesn't match, the preserved data is out of date
if (currentHash == 0 || currentHash != savedHash)
{
outOfDate = true;
Debug.Trace("PreservationFileReader", Path.GetFileName(preservationFile) +
" is out of date (ComputeHashCode)");
}
}
if (outOfDate)
{
bool gotLock = false;
try {
// We need to delete the preservation file together with the assemblies/pdbs
// under the same lock so to avoid bad interleaving where one process
// deletes the .compiled file that another process just created, orphaning
// the files generated by the other process.
// (Dev10 bug 791299)
CompilationLock.GetLock(ref gotLock);
// Give the BuildResult a chance to do some cleanup
result.RemoveOutOfDateResources(this);
// The preservation file is not useable, so delete it
File.Delete(preservationFile);
}
finally {
// Always release the mutex if we had taken it
if (gotLock)
{
CompilationLock.ReleaseLock();
}
}
return(null);
}
}
// Ask the BuildResult to read the data it needs
result.GetPreservedAttributes(this);
return(result);
}
