/// <summary>
/// References usually only contains who they depend on, they do not know who depends on them. Given a reference
/// A we cannot inspect A to find out that B,C,D depend on it. This method will traverse the references and build up this other direction of the graph,
/// therefore we will be able to know given reference A, that B,C,D depend on it.
/// </summary>
private static void AddToDependencyGraph(Dictionary<Reference, List<ReferenceAssemblyExtensionPair>> dependencyGraph, AssemblyNameExtension assemblyName, Reference assemblyReference)
{
// Find the references who the current reference is a dependency for
foreach (Reference dependee in assemblyReference.GetDependees())
{
// This list will contain a list of key value pairs (K: Dependent reference V: assembly Name)
List<ReferenceAssemblyExtensionPair> dependencies = null;
// For a dependee see if we already have a list started
if (!dependencyGraph.TryGetValue(dependee, out dependencies))
{
dependencies = new List<ReferenceAssemblyExtensionPair>();
dependencyGraph.Add(dependee, dependencies);
}
dependencies.Add(new ReferenceAssemblyExtensionPair(assemblyReference, assemblyName));
}
}
/// <summary>
/// Given an unresolved reference (one that we don't know the full name for yet), figure out the
/// full name. Should only be called on references that haven't been resolved yet--otherwise, its
/// a perf problem.
/// </summary>
/// <param name="referenceFusionName">The fusion name for this reference.</param>
/// <param name="rawFileNameCandidate">The file name to match if {RawFileName} is seen. (May be null).</param>
/// <param name="reference">The reference object.</param>
private void ResolveReference
(
AssemblyNameExtension assemblyName,
string rawFileNameCandidate,
Reference reference
)
{
// Now, resolve this reference.
string resolvedPath = null;
string resolvedSearchPath = String.Empty;
bool userRequestedSpecificFile = false;
// A list of assemblies that might have been matches but weren't
ArrayList assembliesConsideredAndRejected = new ArrayList();
// First, look for the dependency in the parents' directories. Unless they are resolved from the GAC or assemblyFoldersEx then
// we should make sure we use the GAC and assemblyFolders resolvers themserves rather than a directory resolver to find the reference.\
// this way we dont get assemblies pulled from the GAC or AssemblyFolders but dont have the marking that they were pulled form there.
Hashtable parentReferenceFolderHash = new Hashtable(StringComparer.OrdinalIgnoreCase);
List<string> parentReferenceFolders = new List<string>();
foreach (Reference parentReference in reference.GetDependees())
{
CalcuateParentAssemblyDirectories(parentReferenceFolderHash, parentReferenceFolders, parentReference);
}
// Build the set of resolvers.
List<Resolver[]> jaggedResolvers = new List<Resolver[]>();
// If a reference has an SDK name on it then we must ONLY resolve it from the SDK which matches the SDKName on the refernce metadata
// this is to support the case where a single reference assembly is selected from the SDK.
// If a reference has the SDKName metadata on it then we will only search using a single resolver, that is the InstalledSDKResolver.
if (reference.SDKName.Length > 0)
{
jaggedResolvers.Add(new Resolver[] { new InstalledSDKResolver(_resolvedSDKReferences, "SDKResolver", _getAssemblyName, _fileExists, _getRuntimeVersion, _targetedRuntimeVersion) });
}
else
{
jaggedResolvers.Add(AssemblyResolution.CompileDirectories(parentReferenceFolders, _fileExists, _getAssemblyName, _getRuntimeVersion, _targetedRuntimeVersion));
jaggedResolvers.Add(_compiledSearchPaths);
}
// Resolve
try
{
resolvedPath = AssemblyResolution.ResolveReference
(
jaggedResolvers,
assemblyName,
reference.SDKName,
rawFileNameCandidate,
reference.IsPrimary,
reference.WantSpecificVersion,
reference.GetExecutableExtensions(_allowedAssemblyExtensions),
reference.HintPath,
reference.AssemblyFolderKey,
assembliesConsideredAndRejected,
out resolvedSearchPath,
out userRequestedSpecificFile
);
}
catch (System.BadImageFormatException e)
{
reference.AddError(new DependencyResolutionException(e.Message, e));
}
// Update the list of assemblies considered and rejected.
reference.AddAssembliesConsideredAndRejected(assembliesConsideredAndRejected);
// If the path was resolved, then specify the full path on the reference.
if (resolvedPath != null)
{
if (!Path.IsPathRooted(resolvedPath))
{
resolvedPath = Path.GetFullPath(resolvedPath);
}
reference.FullPath = resolvedPath;
reference.ResolvedSearchPath = resolvedSearchPath;
reference.UserRequestedSpecificFile = userRequestedSpecificFile;
}
else
{
if (assemblyName != null)
{
reference.AddError
(
new ReferenceResolutionException
(
ResourceUtilities.FormatResourceString("General.CouldNotLocateAssembly", assemblyName.FullName),
null
)
);
}
}
}
/// <summary>
/// Log the source items and dependencies which lead to a given item.
/// </summary>
private void LogReferenceDependenciesAndSourceItems(string fusionName, Reference conflictCandidate)
{
ErrorUtilities.VerifyThrowInternalNull(conflictCandidate, "ConflictCandidate");
Log.LogMessageFromResources(MessageImportance.Low, "ResolveAssemblyReference.FourSpaceIndent", ResourceUtilities.FormatResourceString("ResolveAssemblyReference.ReferenceDependsOn", fusionName, conflictCandidate.FullPath));
if (conflictCandidate.IsPrimary)
{
if (conflictCandidate.IsResolved)
{
LogDependeeReference(conflictCandidate);
}
else
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveAssemblyReference.EightSpaceIndent", ResourceUtilities.FormatResourceString("ResolveAssemblyReference.UnResolvedPrimaryItemSpec", conflictCandidate.PrimarySourceItem));
}
}
// Log the references for the conflict victim
foreach (Reference dependeeReference in conflictCandidate.GetDependees())
{
LogDependeeReference(dependeeReference);
}
}
private void LogReferenceDependenciesAndSourceItems(string fusionName, Reference conflictCandidate)
{
Microsoft.Build.Shared.ErrorUtilities.VerifyThrowInternalNull(conflictCandidate, "ConflictCandidate");
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveAssemblyReference.FourSpaceIndent", new object[] { Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ResolveAssemblyReference.ReferenceDependsOn", new object[] { fusionName, conflictCandidate.FullPath }) });
if (conflictCandidate.IsPrimary)
{
if (conflictCandidate.IsResolved)
{
this.LogDependeeReference(conflictCandidate);
}
else
{
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveAssemblyReference.EightSpaceIndent", new object[] { Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ResolveAssemblyReference.UnResolvedPrimaryItemSpec", new object[] { conflictCandidate.PrimarySourceItem }) });
}
}
foreach (Reference reference in conflictCandidate.GetDependees())
{
this.LogDependeeReference(reference);
}
}
private static void AddToDependencyGraph(Dictionary<Reference, List<ReferenceAssemblyExtensionPair>> dependencyGraph, AssemblyNameExtension assemblyName, Reference assemblyReference)
{
foreach (Reference reference in assemblyReference.GetDependees())
{
List<ReferenceAssemblyExtensionPair> list = null;
if (!dependencyGraph.TryGetValue(reference, out list))
{
list = new List<ReferenceAssemblyExtensionPair>();
dependencyGraph.Add(reference, list);
}
list.Add(new ReferenceAssemblyExtensionPair(assemblyReference, assemblyName));
}
}
private void ResolveReference(AssemblyNameExtension assemblyName, string rawFileNameCandidate, Reference reference)
{
string path = null;
string resolvedSearchPath = string.Empty;
bool userRequestedSpecificFile = false;
ArrayList assembliesConsideredAndRejected = new ArrayList();
Hashtable parentReferenceFolderHash = new Hashtable(StringComparer.OrdinalIgnoreCase);
List<string> parentReferenceFolders = new List<string>();
foreach (Reference reference2 in reference.GetDependees())
{
CalcuateParentAssemblyDirectories(parentReferenceFolderHash, parentReferenceFolders, reference2);
}
List<Microsoft.Build.Tasks.Resolver[]> jaggedResolvers = new List<Microsoft.Build.Tasks.Resolver[]> {
AssemblyResolution.CompileDirectories(parentReferenceFolders, this.fileExists, this.getAssemblyName, this.getRuntimeVersion, this.targetedRuntimeVersion),
this.compiledSearchPaths
};
try
{
path = AssemblyResolution.ResolveReference(jaggedResolvers, assemblyName, rawFileNameCandidate, reference.IsPrimary, reference.WantSpecificVersion, reference.GetExecutableExtensions(this.allowedAssemblyExtensions), reference.HintPath, reference.AssemblyFolderKey, assembliesConsideredAndRejected, out resolvedSearchPath, out userRequestedSpecificFile);
}
catch (BadImageFormatException exception)
{
reference.AddError(new DependencyResolutionException(exception.Message, exception));
}
reference.AddAssembliesConsideredAndRejected(assembliesConsideredAndRejected);
if (path != null)
{
if (!Path.IsPathRooted(path))
{
path = Path.GetFullPath(path);
}
reference.FullPath = path;
reference.ResolvedSearchPath = resolvedSearchPath;
reference.UserRequestedSpecificFile = userRequestedSpecificFile;
}
else if (assemblyName != null)
{
reference.AddError(new ReferenceResolutionException(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("General.CouldNotLocateAssembly", new object[] { assemblyName.FullName }), null));
}
}
