internal bool Execute(Microsoft.Build.Shared.FileExists fileExists, Microsoft.Build.Shared.DirectoryExists directoryExists, Microsoft.Build.Tasks.GetDirectories getDirectories, GetAssemblyName getAssemblyName, GetAssemblyMetadata getAssemblyMetadata, GetRegistrySubKeyNames getRegistrySubKeyNames, GetRegistrySubKeyDefaultValue getRegistrySubKeyDefaultValue, GetLastWriteTime getLastWriteTime, GetAssemblyRuntimeVersion getRuntimeVersion, OpenBaseKey openBaseKey, CheckIfAssemblyInGac checkIfAssemblyIsInGac)
{
bool flag = true;
CodeMarkerStartEnd end = new CodeMarkerStartEnd(CodeMarkerEvent.perfMSBuildResolveAssemblyReferenceBegin, CodeMarkerEvent.perfMSBuildResolveAssemblyReferenceEnd);
try
{
FrameworkName targetFrameworkMoniker = null;
if (!string.IsNullOrEmpty(this.targetedFrameworkMoniker))
{
targetFrameworkMoniker = new FrameworkName(this.targetedFrameworkMoniker);
}
Version targetedRuntimeVersion = this.SetTargetedRuntimeVersion(getRuntimeVersion);
this.LogInputs();
if (!this.VerifyInputConditions())
{
return false;
}
if (this.targetFrameworkDirectories != null)
{
for (int i = 0; i < this.targetFrameworkDirectories.Length; i++)
{
this.targetFrameworkDirectories[i] = Microsoft.Build.Shared.FileUtilities.EnsureTrailingSlash(this.targetFrameworkDirectories[i]);
}
}
AssemblyTableInfo[] assemblyTables = this.GetInstalledAssemblyTableInfo(this.ignoreDefaultInstalledAssemblyTables, this.installedAssemblyTables, new GetListPath(RedistList.GetRedistListPathsFromDisk), this.TargetFrameworkDirectories);
AssemblyTableInfo[] whiteListAssemblyTableInfo = null;
InstalledAssemblies installedAssemblies = null;
RedistList redistList = null;
if ((assemblyTables != null) && (assemblyTables.Length > 0))
{
redistList = RedistList.GetRedistList(assemblyTables);
}
Hashtable blackList = null;
string subsetName = null;
bool flag2 = !string.IsNullOrEmpty(this.ProfileName) && ((this.FullFrameworkFolders.Length > 0) || (this.FullFrameworkAssemblyTables.Length > 0));
bool flag3 = false;
if (((redistList != null) && (redistList.Count > 0)) || (flag2 || this.ShouldUseSubsetBlackList()))
{
if (!flag2 && this.ShouldUseSubsetBlackList())
{
SubsetListFinder finder = new SubsetListFinder(this.targetFrameworkSubsets);
whiteListAssemblyTableInfo = this.GetInstalledAssemblyTableInfo(this.IgnoreDefaultInstalledAssemblySubsetTables, this.InstalledAssemblySubsetTables, new GetListPath(finder.GetSubsetListPathsFromDisk), this.TargetFrameworkDirectories);
if (((whiteListAssemblyTableInfo.Length > 0) && (redistList != null)) && (redistList.Count > 0))
{
blackList = redistList.GenerateBlackList(whiteListAssemblyTableInfo);
}
else
{
base.Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.NoSubsetsFound", new object[0]);
}
if (blackList == null)
{
base.Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.NoRedistAssembliesToGenerateExclusionList", new object[0]);
}
subsetName = GenerateSubSetName(this.targetFrameworkSubsets, this.installedAssemblySubsetTables);
flag3 = true;
}
else if (flag2)
{
AssemblyTableInfo[] fullRedistAssemblyTableInfo = null;
RedistList fullFrameworkRedistList = null;
this.HandleProfile(assemblyTables, out fullRedistAssemblyTableInfo, out blackList, out fullFrameworkRedistList);
redistList = fullFrameworkRedistList;
whiteListAssemblyTableInfo = assemblyTables;
assemblyTables = fullRedistAssemblyTableInfo;
subsetName = this.profileName;
}
if ((redistList != null) && (redistList.Count > 0))
{
installedAssemblies = new InstalledAssemblies(redistList);
}
}
if (redistList != null)
{
for (int j = 0; j < redistList.Errors.Length; j++)
{
Exception exception = redistList.Errors[j];
string str2 = redistList.ErrorFileNames[j];
base.Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.InvalidInstalledAssemblyTablesFile", new object[] { str2, RedistList.RedistListFolder, exception.Message });
}
for (int k = 0; k < redistList.WhiteListErrors.Length; k++)
{
Exception exception2 = redistList.WhiteListErrors[k];
string str3 = redistList.WhiteListErrorFileNames[k];
base.Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.InvalidInstalledAssemblySubsetTablesFile", new object[] { str3, SubsetListFinder.SubsetListFolder, exception2.Message });
}
}
this.ReadStateFile();
this.cache.SetGetLastWriteTime(getLastWriteTime);
this.cache.SetInstalledAssemblyInformation(assemblyTables);
getAssemblyName = this.cache.CacheDelegate(getAssemblyName);
getAssemblyMetadata = this.cache.CacheDelegate(getAssemblyMetadata);
fileExists = this.cache.CacheDelegate(fileExists);
getDirectories = this.cache.CacheDelegate(getDirectories);
getRuntimeVersion = this.cache.CacheDelegate(getRuntimeVersion);
this.projectTargetFramework = this.FrameworkVersionFromString(this.projectTargetFrameworkAsString);
this.FilterBySubtypeAndTargetFramework();
DependentAssembly[] idealRemappings = null;
if (this.FindDependencies)
{
try
{
idealRemappings = this.GetAssemblyRemappingsFromAppConfig();
}
catch (AppConfigException exception3)
{
base.Log.LogErrorWithCodeFromResources(null, exception3.FileName, exception3.Line, exception3.Column, 0, 0, "ResolveAssemblyReference.InvalidAppConfig", new object[] { this.AppConfigFile, exception3.Message });
return false;
}
}
System.Reflection.ProcessorArchitecture targetProcessorArchitecture = TargetProcessorArchitectureToEnumeration(this.targetProcessorArchitecture);
if (checkIfAssemblyIsInGac == null)
{
checkIfAssemblyIsInGac = new CheckIfAssemblyInGac(this.CheckForAssemblyInGac);
}
ReferenceTable dependencyTable = new ReferenceTable(this.findDependencies, this.findSatellites, this.findSerializationAssemblies, this.findRelatedFiles, this.searchPaths, this.allowedAssemblyExtensions, this.relatedFileExtensions, this.candidateAssemblyFiles, this.targetFrameworkDirectories, installedAssemblies, targetProcessorArchitecture, fileExists, directoryExists, getDirectories, getAssemblyName, getAssemblyMetadata, getRegistrySubKeyNames, getRegistrySubKeyDefaultValue, openBaseKey, getRuntimeVersion, targetedRuntimeVersion, this.projectTargetFramework, targetFrameworkMoniker, base.Log, this.latestTargetFrameworkDirectories, this.copyLocalDependenciesWhenParentReferenceInGac, checkIfAssemblyIsInGac);
ArrayList exceptions = new ArrayList();
subsetName = flag3 ? subsetName : this.targetedFrameworkMoniker;
bool flag4 = false;
if (this.AutoUnify && this.FindDependencies)
{
dependencyTable.ComputeClosure(null, this.assemblyFiles, this.assemblyNames, exceptions);
try
{
flag4 = false;
if ((redistList != null) && (redistList.Count > 0))
{
flag4 = dependencyTable.MarkReferencesForExclusion(blackList);
}
}
catch (InvalidOperationException exception4)
{
base.Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.ProblemDeterminingFrameworkMembership", new object[] { exception4.Message });
return false;
}
if (flag4)
{
dependencyTable.RemoveReferencesMarkedForExclusion(true, subsetName);
}
AssemblyNameReference[] referenceArray = null;
dependencyTable.ResolveConflicts(out idealRemappings, out referenceArray);
}
dependencyTable.ComputeClosure(idealRemappings, this.assemblyFiles, this.assemblyNames, exceptions);
try
{
flag4 = false;
if ((redistList != null) && (redistList.Count > 0))
{
flag4 = dependencyTable.MarkReferencesForExclusion(blackList);
}
}
catch (InvalidOperationException exception5)
{
base.Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.ProblemDeterminingFrameworkMembership", new object[] { exception5.Message });
return false;
}
if (flag4)
{
dependencyTable.RemoveReferencesMarkedForExclusion(false, subsetName);
}
DependentAssembly[] assemblyArray2 = null;
AssemblyNameReference[] conflictingReferences = null;
dependencyTable.ResolveConflicts(out assemblyArray2, out conflictingReferences);
dependencyTable.GetReferenceItems(out this.resolvedFiles, out this.resolvedDependencyFiles, out this.relatedFiles, out this.satelliteFiles, out this.serializationAssemblyFiles, out this.scatterFiles, out this.copyLocalFiles);
if (this.FindDependencies)
{
this.PopulateSuggestedRedirects(assemblyArray2);
}
if (this.stateFile != null)
{
this.filesWritten.Add(new TaskItem(this.stateFile));
}
this.WriteStateFile();
flag = this.LogResults(dependencyTable, assemblyArray2, conflictingReferences, exceptions);
this.DumpTargetProfileLists(assemblyTables, whiteListAssemblyTableInfo, dependencyTable);
return (flag && !base.Log.HasLoggedErrors);
}
catch (ArgumentException exception6)
{
base.Log.LogErrorWithCodeFromResources("General.InvalidArgument", new object[] { exception6.Message });
}
catch (InvalidParameterValueException exception7)
{
base.Log.LogErrorWithCodeFromResources(null, "", 0, 0, 0, 0, "ResolveAssemblyReference.InvalidParameter", new object[] { exception7.ParamName, exception7.ActualValue, exception7.Message });
}
finally
{
if (end != null)
{
end.Dispose();
}
}
return (flag && !base.Log.HasLoggedErrors);
}
/// <summary>
/// Execute the task.
/// </summary>
/// <param name="fileExists">Delegate used for checking for the existence of a file.</param>
/// <param name="directoryExists">Delegate used for checking for the existence of a directory.</param>
/// <param name="getDirectories">Delegate used for finding directories.</param>
/// <param name="getAssemblyName">Delegate used for finding fusion names of assemblyFiles.</param>
/// <param name="getAssemblyMetadata">Delegate used for finding dependencies of a file.</param>
/// <param name="getRegistrySubKeyNames">Used to get registry subkey names.</param>
/// <param name="getRegistrySubKeyDefaultValue">Used to get registry default values.</param>
/// <param name="getLastWriteTime">Delegate used to get the last write time.</param>
/// <returns>True if there was success.</returns>
internal bool Execute
(
FileExists fileExists,
DirectoryExists directoryExists,
GetDirectories getDirectories,
GetAssemblyName getAssemblyName,
GetAssemblyMetadata getAssemblyMetadata,
GetRegistrySubKeyNames getRegistrySubKeyNames,
GetRegistrySubKeyDefaultValue getRegistrySubKeyDefaultValue,
GetLastWriteTime getLastWriteTime,
GetAssemblyRuntimeVersion getRuntimeVersion,
OpenBaseKey openBaseKey,
GetAssemblyPathInGac getAssemblyPathInGac,
IsWinMDFile isWinMDFile,
ReadMachineTypeFromPEHeader readMachineTypeFromPEHeader
)
{
bool success = true;
#if (!STANDALONEBUILD)
using (new CodeMarkerStartEnd(CodeMarkerEvent.perfMSBuildResolveAssemblyReferenceBegin, CodeMarkerEvent.perfMSBuildResolveAssemblyReferenceEnd))
#endif
{
try
{
FrameworkNameVersioning frameworkMoniker = null;
if (!String.IsNullOrEmpty(_targetedFrameworkMoniker))
{
try
{
frameworkMoniker = new FrameworkNameVersioning(_targetedFrameworkMoniker);
}
catch (ArgumentException)
{
// The exception doesn't contain the bad value, so log it ourselves
Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.InvalidParameter", "TargetFrameworkMoniker", _targetedFrameworkMoniker, String.Empty);
return false;
}
}
Version targetedRuntimeVersion = SetTargetedRuntimeVersion(_targetedRuntimeVersionRawValue);
// Log task inputs.
LogInputs();
if (!VerifyInputConditions())
{
return false;
}
_logVerboseSearchResults = Environment.GetEnvironmentVariable("MSBUILDLOGVERBOSERARSEARCHRESULTS") != null;
// Loop through all the target framework directories that were passed in,
// and ensure that they all have a trailing slash. This is necessary
// for the string comparisons we will do later on.
if (_targetFrameworkDirectories != null)
{
for (int i = 0; i < _targetFrameworkDirectories.Length; i++)
{
_targetFrameworkDirectories[i] = FileUtilities.EnsureTrailingSlash(_targetFrameworkDirectories[i]);
}
}
// Validate the contents of the InstalledAssemblyTables parameter.
AssemblyTableInfo[] installedAssemblyTableInfo = GetInstalledAssemblyTableInfo(_ignoreDefaultInstalledAssemblyTables, _installedAssemblyTables, new GetListPath(RedistList.GetRedistListPathsFromDisk), TargetFrameworkDirectories);
AssemblyTableInfo[] whiteListSubsetTableInfo = null;
InstalledAssemblies installedAssemblies = null;
RedistList redistList = null;
if (installedAssemblyTableInfo != null && installedAssemblyTableInfo.Length > 0)
{
redistList = RedistList.GetRedistList(installedAssemblyTableInfo);
}
Hashtable blackList = null;
// The name of the subset if it is generated or the name of the profile. This will be used for error messages and logging.
string subsetOrProfileName = null;
// Are we targeting a profile
bool targetingProfile = !String.IsNullOrEmpty(ProfileName) && ((FullFrameworkFolders.Length > 0) || (FullFrameworkAssemblyTables.Length > 0));
bool targetingSubset = false;
List<Exception> whiteListErrors = new List<Exception>();
List<string> whiteListErrorFilesNames = new List<string>();
// Check for partial success in GetRedistList and log any tolerated exceptions.
if (redistList != null && redistList.Count > 0 || targetingProfile || ShouldUseSubsetBlackList())
{
// If we are not targeting a dev 10 profile and we have the required components to generate a orcas style subset, do so
if (!targetingProfile && ShouldUseSubsetBlackList())
{
// Based in the target framework subset names find the paths to the files
SubsetListFinder whiteList = new SubsetListFinder(_targetFrameworkSubsets);
whiteListSubsetTableInfo = GetInstalledAssemblyTableInfo(IgnoreDefaultInstalledAssemblySubsetTables, InstalledAssemblySubsetTables, new GetListPath(whiteList.GetSubsetListPathsFromDisk), TargetFrameworkDirectories);
if (whiteListSubsetTableInfo.Length > 0 && (redistList != null && redistList.Count > 0))
{
blackList = redistList.GenerateBlackList(whiteListSubsetTableInfo, whiteListErrors, whiteListErrorFilesNames);
}
else
{
Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.NoSubsetsFound");
}
// Could get into this situation if the redist list files were full of junk and no assemblies were read in.
if (blackList == null)
{
Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.NoRedistAssembliesToGenerateExclusionList");
}
subsetOrProfileName = GenerateSubSetName(_targetFrameworkSubsets, _installedAssemblySubsetTables);
targetingSubset = true;
}
else
{
// We are targeting a profile
if (targetingProfile)
{
// When targeting a profile we want the redist list to be the full framework redist list, since this is what should be used
// when unifying assemblies ect.
AssemblyTableInfo[] fullRedistAssemblyTableInfo = null;
RedistList fullFrameworkRedistList = null;
HandleProfile(installedAssemblyTableInfo /*This is the table info related to the profile*/, out fullRedistAssemblyTableInfo, out blackList, out fullFrameworkRedistList);
// Make sure the redist list and the installedAsemblyTableInfo structures point to the full framework, we replace the installedAssemblyTableInfo
// which contained the information about the profile redist files with the one from the full framework because when doing anything with the RAR cache
// we want to use the full frameworks redist list. Essentailly after generating the exclusion list the job of the profile redist list is done.
redistList = fullFrameworkRedistList;
// Save the profile redist list file locations as the whiteList
whiteListSubsetTableInfo = installedAssemblyTableInfo;
// Set the installed assembly table to the full redist list values
installedAssemblyTableInfo = fullRedistAssemblyTableInfo;
subsetOrProfileName = _profileName;
}
}
if (redistList != null && redistList.Count > 0)
{
installedAssemblies = new InstalledAssemblies(redistList);
}
}
// Print out any errors reading the redist list.
if (redistList != null)
{
// Some files may have been skipped. Log warnings for these.
for (int i = 0; i < redistList.Errors.Length; ++i)
{
Exception e = redistList.Errors[i];
string filename = redistList.ErrorFileNames[i];
// Give the user a warning about the bad file (or files).
Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.InvalidInstalledAssemblyTablesFile", filename, RedistList.RedistListFolder, e.Message);
}
// Some files may have been skipped. Log warnings for these.
for (int i = 0; i < whiteListErrors.Count; ++i)
{
Exception e = whiteListErrors[i];
string filename = whiteListErrorFilesNames[i];
// Give the user a warning about the bad file (or files).
Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.InvalidInstalledAssemblySubsetTablesFile", filename, SubsetListFinder.SubsetListFolder, e.Message);
}
}
// Load any prior saved state.
ReadStateFile();
_cache.SetGetLastWriteTime(getLastWriteTime);
_cache.SetInstalledAssemblyInformation(installedAssemblyTableInfo);
// Cache delegates.
getAssemblyName = _cache.CacheDelegate(getAssemblyName);
getAssemblyMetadata = _cache.CacheDelegate(getAssemblyMetadata);
fileExists = _cache.CacheDelegate(fileExists);
getDirectories = _cache.CacheDelegate(getDirectories);
getRuntimeVersion = _cache.CacheDelegate(getRuntimeVersion);
_projectTargetFramework = FrameworkVersionFromString(_projectTargetFrameworkAsString);
// Filter out all Assemblies that have SubType!='', or higher framework
FilterBySubtypeAndTargetFramework();
// Compute the set of bindingRedirect remappings.
DependentAssembly[] appConfigRemappedAssemblies = null;
if (FindDependencies)
{
try
{
appConfigRemappedAssemblies = GetAssemblyRemappingsFromAppConfig();
}
catch (AppConfigException e)
{
Log.LogErrorWithCodeFromResources(null, e.FileName, e.Line, e.Column, 0, 0, "ResolveAssemblyReference.InvalidAppConfig", AppConfigFile, e.Message);
return false;
}
}
SystemProcessorArchitecture processorArchitecture = TargetProcessorArchitectureToEnumeration(_targetProcessorArchitecture);
// Start the table of dependencies with all of the primary references.
ReferenceTable dependencyTable = new ReferenceTable
(
BuildEngine,
_findDependencies,
_findSatellites,
_findSerializationAssemblies,
_findRelatedFiles,
_searchPaths,
_allowedAssemblyExtensions,
_relatedFileExtensions,
_candidateAssemblyFiles,
_resolvedSDKReferences,
_targetFrameworkDirectories,
installedAssemblies,
processorArchitecture,
fileExists,
directoryExists,
getDirectories,
getAssemblyName,
getAssemblyMetadata,
getRegistrySubKeyNames,
getRegistrySubKeyDefaultValue,
openBaseKey,
getRuntimeVersion,
targetedRuntimeVersion,
_projectTargetFramework,
frameworkMoniker,
Log,
_latestTargetFrameworkDirectories,
_copyLocalDependenciesWhenParentReferenceInGac,
DoNotCopyLocalIfInGac,
getAssemblyPathInGac,
isWinMDFile,
_ignoreVersionForFrameworkReferences,
readMachineTypeFromPEHeader,
_warnOrErrorOnTargetArchitectureMismatch,
_ignoreTargetFrameworkAttributeVersionMismatch,
_unresolveFrameworkAssembliesFromHigherFrameworks
);
// If AutoUnify, then compute the set of assembly remappings.
ArrayList generalResolutionExceptions = new ArrayList();
subsetOrProfileName = targetingSubset && String.IsNullOrEmpty(_targetedFrameworkMoniker) ? subsetOrProfileName : _targetedFrameworkMoniker;
bool excludedReferencesExist = false;
DependentAssembly[] autoUnifiedRemappedAssemblies = null;
AssemblyNameReference[] autoUnifiedRemappedAssemblyReferences = null;
if (AutoUnify && FindDependencies)
{
// Compute all dependencies.
dependencyTable.ComputeClosure
(
// Use any app.config specified binding redirects so that later when we output suggested redirects
// for the GenerateBindingRedirects target, we don't suggest ones that the user already wrote
appConfigRemappedAssemblies,
_assemblyFiles,
_assemblyNames,
generalResolutionExceptions
);
try
{
excludedReferencesExist = false;
if (redistList != null && redistList.Count > 0)
{
excludedReferencesExist = dependencyTable.MarkReferencesForExclusion(blackList);
}
}
catch (InvalidOperationException e)
{
Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.ProblemDeterminingFrameworkMembership", e.Message);
return false;
}
if (excludedReferencesExist)
{
dependencyTable.RemoveReferencesMarkedForExclusion(true /* Remove the reference and do not warn*/, subsetOrProfileName);
}
// Based on the closure, get a table of ideal remappings needed to
// produce zero conflicts.
dependencyTable.ResolveConflicts
(
out autoUnifiedRemappedAssemblies,
out autoUnifiedRemappedAssemblyReferences
);
}
DependentAssembly[] allRemappedAssemblies = CombineRemappedAssemblies(appConfigRemappedAssemblies, autoUnifiedRemappedAssemblies);
// Compute all dependencies.
dependencyTable.ComputeClosure(allRemappedAssemblies, _assemblyFiles, _assemblyNames, generalResolutionExceptions);
try
{
excludedReferencesExist = false;
if (redistList != null && redistList.Count > 0)
{
excludedReferencesExist = dependencyTable.MarkReferencesForExclusion(blackList);
}
}
catch (InvalidOperationException e)
{
Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.ProblemDeterminingFrameworkMembership", e.Message);
return false;
}
if (excludedReferencesExist)
{
dependencyTable.RemoveReferencesMarkedForExclusion(false /* Remove the reference and warn*/, subsetOrProfileName);
}
// Resolve any conflicts.
DependentAssembly[] idealAssemblyRemappings = null;
AssemblyNameReference[] idealAssemblyRemappingsIdentities = null;
dependencyTable.ResolveConflicts
(
out idealAssemblyRemappings,
out idealAssemblyRemappingsIdentities
);
// Build the output tables.
dependencyTable.GetReferenceItems
(
out _resolvedFiles,
out _resolvedDependencyFiles,
out _relatedFiles,
out _satelliteFiles,
out _serializationAssemblyFiles,
out _scatterFiles,
out _copyLocalFiles
);
// If we're not finding dependencies, then don't suggest redirects (they're only about dependencies).
if (FindDependencies)
{
// Build the table of suggested redirects. If we're auto-unifying, we want to output all the
// assemblies that we auto-unified so that GenerateBindingRedirects can consume them,
// not just the required ones for build to succeed
DependentAssembly[] remappings = AutoUnify ? autoUnifiedRemappedAssemblies : idealAssemblyRemappings;
AssemblyNameReference[] remappedReferences = AutoUnify ? autoUnifiedRemappedAssemblyReferences : idealAssemblyRemappingsIdentities;
PopulateSuggestedRedirects(remappings, remappedReferences);
}
bool useSystemRuntime = false;
foreach (var reference in dependencyTable.References.Keys)
{
if (string.Equals(SystemRuntimeAssemblyName, reference.Name, StringComparison.OrdinalIgnoreCase))
{
useSystemRuntime = true;
break;
}
}
if (!useSystemRuntime && !FindDependencies)
{
// when we are not producing the dependency graph look for direct dependencies of primary references.
foreach (var resolvedReference in dependencyTable.References.Values)
{
var rawDependencies = GetDependencies(resolvedReference, fileExists, getAssemblyMetadata);
if (rawDependencies != null)
{
foreach (var dependentReference in rawDependencies)
{
if (string.Equals(SystemRuntimeAssemblyName, dependentReference.Name, StringComparison.OrdinalIgnoreCase))
{
useSystemRuntime = true;
break;
}
}
}
if (useSystemRuntime)
{
break;
}
}
}
this.DependsOnSystemRuntime = useSystemRuntime.ToString();
WriteStateFile();
// Save the new state out and put into the file exists if it is actually on disk.
if (_stateFile != null && fileExists(_stateFile))
{
_filesWritten.Add(new TaskItem(_stateFile));
}
// Log the results.
success = LogResults(dependencyTable, idealAssemblyRemappings, idealAssemblyRemappingsIdentities, generalResolutionExceptions);
DumpTargetProfileLists(installedAssemblyTableInfo, whiteListSubsetTableInfo, dependencyTable);
if (processorArchitecture != SystemProcessorArchitecture.None && _warnOrErrorOnTargetArchitectureMismatch != WarnOrErrorOnTargetArchitectureMismatchBehavior.None)
{
foreach (ITaskItem item in _resolvedFiles)
{
AssemblyNameExtension assemblyName = null;
if (fileExists(item.ItemSpec) && !Reference.IsFrameworkFile(item.ItemSpec, _targetFrameworkDirectories))
{
try
{
assemblyName = getAssemblyName(item.ItemSpec);
}
catch (System.IO.FileLoadException)
{
// Its pretty hard to get here, you need an assembly that contains a valid reference
// to a dependent assembly that, in turn, throws a FileLoadException during GetAssemblyName.
// Still it happened once, with an older version of the CLR.
// ...falling through and relying on the targetAssemblyName==null behavior below...
}
catch (System.IO.FileNotFoundException)
{
// Its pretty hard to get here, also since we do a file existence check right before calling this method so it can only happen if the file got deleted between that check and this call.
}
catch (UnauthorizedAccessException)
{
}
catch (BadImageFormatException)
{
}
}
if (assemblyName != null)
{
SystemProcessorArchitecture assemblyArch = assemblyName.ProcessorArchitecture;
// If the assembly is MSIL or none it can work anywhere so there does not need to be any warning ect.
if (assemblyArch == SystemProcessorArchitecture.MSIL || assemblyArch == SystemProcessorArchitecture.None)
{
continue;
}
if (processorArchitecture != assemblyArch)
{
if (_warnOrErrorOnTargetArchitectureMismatch == WarnOrErrorOnTargetArchitectureMismatchBehavior.Error)
{
Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.MismatchBetweenTargetedAndReferencedArch", ProcessorArchitectureToString(processorArchitecture), item.GetMetadata("OriginalItemSpec"), ProcessorArchitectureToString(assemblyArch));
}
else
{
Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.MismatchBetweenTargetedAndReferencedArch", ProcessorArchitectureToString(processorArchitecture), item.GetMetadata("OriginalItemSpec"), ProcessorArchitectureToString(assemblyArch));
}
}
}
}
}
return success && !Log.HasLoggedErrors;
}
catch (ArgumentException e)
{
Log.LogErrorWithCodeFromResources("General.InvalidArgument", e.Message);
}
// InvalidParameterValueException is thrown inside RAR when we find a specific parameter
// has an invalid value. It's then caught up here so that we can abort the task.
catch (InvalidParameterValueException e)
{
Log.LogErrorWithCodeFromResources(null, "", 0, 0, 0, 0,
"ResolveAssemblyReference.InvalidParameter", e.ParamName, e.ActualValue, e.Message);
}
}
return success && !Log.HasLoggedErrors;
}
public void SubsetListFinderNullSubsetExistsButNotXml()
{
string frameworkDirectory = Path.Combine(ObjectModelHelpers.TempProjectDir, "SubsetListsTestExistsNotXml");
string subsetDirectory = Path.Combine(frameworkDirectory, SubsetListFinder.SubsetListFolder);
string clientXml = Path.Combine(subsetDirectory, "Clent.Notxml");
string fooXml = Path.Combine(subsetDirectory, "Foo.Notxml");
try
{
Directory.CreateDirectory(subsetDirectory);
File.WriteAllText(clientXml, "Random File Contents");
File.WriteAllText(fooXml, "Random File Contents");
SubsetListFinder finder = new SubsetListFinder(new string[] { "Client", "Foo" });
string[] returnArray = finder.GetSubsetListPathsFromDisk(frameworkDirectory);
Assert.Equal(0, returnArray.Length); // "Expected there to be two elements in the array"
}
finally
{
Directory.Delete(frameworkDirectory, true);
}
}
public void SubsetListFinderVerifyEmptyInSubsetsToSearchForAndCaching()
{
// Verify the program will not crach when an empty string is passed in and that when we call the method twice that we get the
// exact same array of strings back.
SubsetListFinder finder = new SubsetListFinder(new string[] { "Clent", string.Empty, "Bar" });
string[] returnArray = finder.GetSubsetListPathsFromDisk("FrameworkDirectory");
string[] returnArray2 = finder.GetSubsetListPathsFromDisk("FrameworkDirectory");
Assert.True(Object.ReferenceEquals(returnArray, returnArray2)); // "Expected the string arrays to be the exact same reference"
// Verify that if i call the method again with a different target framework directory that I get a different array back
string[] returnArray3 = finder.GetSubsetListPathsFromDisk("FrameworkDirectory2");
Assert.False(Object.ReferenceEquals(returnArray2, returnArray3)); // "Expected the string arrays to not be the exact same reference"
}
public void SubsetListFinderEmptySubsetToSearchFor()
{
SubsetListFinder finder = new SubsetListFinder(new string[0]);
string[] returnArray = finder.GetSubsetListPathsFromDisk("FrameworkDirectory");
Assert.Equal(0, returnArray.Length); // "Expected the array returned to be 0 lengh"
}
public void SubsetListFinderNullSubsetToSearchFor()
{
Assert.Throws<ArgumentNullException>(() =>
{
SubsetListFinder finder = new SubsetListFinder(null);
}
);
}
public void SubsetListFinderNullFrameworkDirectory()
{
Assert.Throws<ArgumentNullException>(() =>
{
SubsetListFinder finder = new SubsetListFinder(new string[0]);
finder.GetSubsetListPathsFromDisk(null);
}
);
}