public override bool Resolve(AssemblyNameExtension assemblyName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { string path = GlobalAssemblyCache.GetLocation(assemblyName, base.targetProcessorArchitecture, base.getRuntimeVersion, base.targetedRuntimeVersion, false, base.fileExists, null, null, wantSpecificVersion); if (((path != null) && (path.Length > 0)) && base.fileExists(path)) { foundPath = path; return true; } if (assembliesConsideredAndRejected != null) { ResolutionSearchLocation location = new ResolutionSearchLocation { FileNameAttempted = assemblyName.FullName, SearchPath = base.searchPathElement, AssemblyName = assemblyName, Reason = NoMatchReason.NotInGac }; assembliesConsideredAndRejected.Add(location); } } return false; }
public override bool Resolve(AssemblyNameExtension assemblyName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile) { foundPath = null; userRequestedSpecificFile = false; if (rawFileNameCandidate != null) { if (base.fileExists(rawFileNameCandidate)) { userRequestedSpecificFile = true; foundPath = rawFileNameCandidate; return true; } if (assembliesConsideredAndRejected != null) { ResolutionSearchLocation location = null; location = new ResolutionSearchLocation { FileNameAttempted = rawFileNameCandidate, SearchPath = base.searchPathElement, Reason = NoMatchReason.NotAFileNameOnDisk }; assembliesConsideredAndRejected.Add(location); } } return false; }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assemblyname of the reference.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> public override bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile ) { foundPath = null; userRequestedSpecificFile = false; // Resolve to the given path. string resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, searchPathElement, assembliesConsideredAndRejected); if (resolvedPath != null) { foundPath = resolvedPath; return true; } return false; }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assemblyname of the reference.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> public override bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile ) { if (hintPath != null && hintPath.Length > 0) { if (ResolveAsFile(hintPath, assemblyName, isPrimaryProjectReference, wantSpecificVersion, true, assembliesConsideredAndRejected)) { userRequestedSpecificFile = true; foundPath = hintPath; return true; } } foundPath = null; userRequestedSpecificFile = false; return false; }
/// <summary> /// Implementation guts for ResolveReference. /// </summary> /// <param name="jaggedResolvers">The array of resolvers to search with.</param> /// <param name="assemblyName">The assembly name to look up.</param> /// <param name="rawFileNameCandidate">The file name to match if {RawFileName} is seen. (May be null).</param> /// <param name="isPrimaryProjectReference">True if this is a primary reference directly from the project file.</param> /// <param name="executableExtensions">The filename extension of the assembly. Must be this or its no match.</param> /// <param name="hintPath">This reference's hintpath</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="resolvedSearchPath">Receives the searchPath that the reference was resolved at. Empty if not resolved.</param> /// <param name="userRequestedSpecificFile"> This will be true if the user requested a specific file.</param> /// <returns>The resolved path</returns> internal static string ResolveReference ( IEnumerable<Resolver[]> jaggedResolvers, AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string resolvedSearchPath, out bool userRequestedSpecificFile ) { // Initialize outs. userRequestedSpecificFile = false; resolvedSearchPath = String.Empty; // Search each group of resolvers foreach (Resolver[] resolvers in jaggedResolvers) { // Tolerate null resolvers. if (resolvers == null) { break; } // Search each searchpath. foreach (Resolver resolver in resolvers) { string fileLocation; if ( resolver.Resolve ( assemblyName, sdkName, rawFileNameCandidate, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, hintPath, assemblyFolderKey, assembliesConsideredAndRejected, out fileLocation, out userRequestedSpecificFile ) ) { resolvedSearchPath = resolver.SearchPath; return fileLocation; } } } return null; }
public override bool Execute() { FrameworkName frameworkmoniker = null; FrameworkName name2 = null; bool flag = false; try { frameworkmoniker = new FrameworkName(this.TargetFrameworkMoniker); flag = !string.IsNullOrEmpty(frameworkmoniker.Profile); if (flag) { name2 = new FrameworkName(frameworkmoniker.Identifier, frameworkmoniker.Version); } if ((!this.bypassFrameworkInstallChecks && frameworkmoniker.Identifier.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase)) && (frameworkmoniker.Version.Major < 4)) { if (!net35SP1SentinelAssemblyFound.HasValue) { AssemblyNameExtension strongName = new AssemblyNameExtension(NET35SP1SentinelAssemblyName); net35SP1SentinelAssemblyFound = new bool?(!string.IsNullOrEmpty(GlobalAssemblyCache.GetLocation(strongName, System.Reflection.ProcessorArchitecture.MSIL, runtimeVersion => "v2.0.50727", new Version("2.0.57027"), false, new Microsoft.Build.Shared.FileExists(Microsoft.Build.Shared.FileUtilities.FileExistsNoThrow), GlobalAssemblyCache.pathFromFusionName, GlobalAssemblyCache.gacEnumerator, false))); } if (!net35SP1SentinelAssemblyFound.Value) { base.Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.NETFX35SP1NotIntstalled", new object[] { this.TargetFrameworkMoniker }); } } } catch (ArgumentException exception) { base.Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.InvalidTargetFrameworkMoniker", new object[] { this.TargetFrameworkMoniker, exception.Message }); return false; } try { this.tfmPaths = this.GetPaths(this.rootPath, frameworkmoniker); if ((this.tfmPaths != null) && (this.tfmPaths.Count > 0)) { this.TargetFrameworkMonikerDisplayName = ToolLocationHelper.GetDisplayNameForTargetFrameworkDirectory(this.tfmPaths[0], frameworkmoniker); } if (flag && (this.tfmPaths != null)) { this.tfmPathsNoProfile = this.GetPaths(this.rootPath, name2); } if (!flag) { this.tfmPathsNoProfile = this.tfmPaths; } } catch (Exception exception2) { base.Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.ProblemGeneratingReferencePaths", new object[] { this.TargetFrameworkMoniker, exception2.Message }); if (Microsoft.Build.Shared.ExceptionHandling.IsCriticalException(exception2)) { throw; } this.tfmPathsNoProfile = null; this.TargetFrameworkMonikerDisplayName = null; } return !base.Log.HasLoggedErrors; }
private static string CheckForFullFusionNameInGac(AssemblyNameExtension assemblyName, string targetProcessorArchitecture, GetPathFromFusionName getPathFromFusionName) { string fullName = assemblyName.FullName; if ((targetProcessorArchitecture != null) && !assemblyName.HasProcessorArchitectureInFusionName) { fullName = fullName + ", ProcessorArchitecture=" + targetProcessorArchitecture; } return getPathFromFusionName(fullName); }
private bool CheckForAssemblyInGac(AssemblyNameExtension assemblyName, System.Reflection.ProcessorArchitecture targetProcessorArchitecture, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVersion, Microsoft.Build.Shared.FileExists fileExists) { string str = null; if (assemblyName.Version != null) { str = GlobalAssemblyCache.GetLocation(assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, true, fileExists, null, null, false); } return (str != null); }
public UnifiedAssemblyName(AssemblyNameExtension preUnified, AssemblyNameExtension postUnified, bool isUnified, UnificationReason unificationReason, bool isPrerequisite, bool? isRedistRoot, string redistName) { _preUnified = preUnified; _postUnified = postUnified; _isUnified = isUnified; _isPrerequisite = isPrerequisite; _isRedistRoot = isRedistRoot; _redistName = redistName; _unificationReason = unificationReason; }
public UnifiedAssemblyName(AssemblyNameExtension preUnified, AssemblyNameExtension postUnified, bool isUnified, Microsoft.Build.Tasks.UnificationReason unificationReason, bool isPrerequisite, bool? isRedistRoot, string redistName) { this.preUnified = preUnified; this.postUnified = postUnified; this.isUnified = isUnified; this.isPrerequisite = isPrerequisite; this.isRedistRoot = isRedistRoot; this.redistName = redistName; this.unificationReason = unificationReason; }
internal static string GetLocation(AssemblyNameExtension strongName, ProcessorArchitecture targetProcessorArchitecture, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVersion, bool fullFusionName, Microsoft.Build.Shared.FileExists fileExists, GetPathFromFusionName getPathFromFusionName, GetGacEnumerator getGacEnumerator, bool specificVersion) { string str = null; if (((strongName.GetPublicKeyToken() == null) || (strongName.GetPublicKeyToken().Length == 0)) && (strongName.FullName.IndexOf("PublicKeyToken", StringComparison.OrdinalIgnoreCase) != -1)) { return str; } getPathFromFusionName = getPathFromFusionName ?? pathFromFusionName; getGacEnumerator = getGacEnumerator ?? gacEnumerator; if (!strongName.HasProcessorArchitectureInFusionName) { if ((targetProcessorArchitecture != ProcessorArchitecture.MSIL) && (targetProcessorArchitecture != ProcessorArchitecture.None)) { string str2 = ResolveAssemblyReference.ProcessorArchitectureToString(targetProcessorArchitecture); if (fullFusionName) { str = CheckForFullFusionNameInGac(strongName, str2, getPathFromFusionName); } else { str = GetLocationImpl(strongName, str2, getRuntimeVersion, targetedRuntimeVersion, fileExists, getPathFromFusionName, getGacEnumerator, specificVersion); } if ((str != null) && (str.Length > 0)) { return str; } } if (fullFusionName) { str = CheckForFullFusionNameInGac(strongName, "MSIL", getPathFromFusionName); } else { str = GetLocationImpl(strongName, "MSIL", getRuntimeVersion, targetedRuntimeVersion, fileExists, getPathFromFusionName, getGacEnumerator, specificVersion); } if ((str != null) && (str.Length > 0)) { return str; } } if (fullFusionName) { str = CheckForFullFusionNameInGac(strongName, null, getPathFromFusionName); } else { str = GetLocationImpl(strongName, null, getRuntimeVersion, targetedRuntimeVersion, fileExists, getPathFromFusionName, getGacEnumerator, specificVersion); } if ((str != null) && (str.Length > 0)) { return str; } return null; }
private void GetAssemblyMetadata(string path, out AssemblyNameExtension[] dependencies, out string[] scatterFiles) { FileState fileState = this.GetFileState(path); if (fileState.dependencies == null) { this.getAssemblyMetadata(path, out fileState.dependencies, out fileState.scatterFiles); this.isDirty = true; } dependencies = fileState.dependencies; scatterFiles = fileState.scatterFiles; }
internal AssemblyEntry FindHighestVersionInRedistList(AssemblyNameExtension assemblyName) { foreach (AssemblyEntry entry in this.redistList.FindAssemblyNameFromSimpleName(assemblyName.Name)) { if (entry.AssemblyNameExtension.EqualsIgnoreVersion(assemblyName)) { return entry; } } return null; }
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)); } }
/// <summary> /// Do a partial comparison between two assembly name extensions. /// Compare the fields of A and B on the following conditions: /// 1) A.Field has a non null value /// 2) The field has been selected in the comparison flags or the default comparison flags are passed in. /// /// If A.Field is null then we will not compare A.Field and B.Field even when the comparison flag is set for that field unless skipNullFields is false. /// </summary> internal bool PartialNameCompare(AssemblyNameExtension that, PartialComparisonFlags comparisonFlags, bool considerRetargetableFlag) { // Pointer compare. if (Object.ReferenceEquals(this, that)) { return(true); } // If that is null then this and that are not equal. Also, this would cause a crash on the next line. if (Object.ReferenceEquals(that, null)) { return(false); } // Do both have assembly names? if (_asAssemblyName != null && that._asAssemblyName != null) { // Pointer compare. if (Object.ReferenceEquals(_asAssemblyName, that._asAssemblyName)) { return(true); } } // Do the names match? if ((comparisonFlags & PartialComparisonFlags.SimpleName) != 0 && Name != null && !String.Equals(Name, that.Name, StringComparison.OrdinalIgnoreCase)) { return(false); } if ((comparisonFlags & PartialComparisonFlags.Version) != 0 && Version != null && this.Version != that.Version) { return(false); } if ((comparisonFlags & PartialComparisonFlags.Culture) != 0 && CultureInfo != null && (that.CultureInfo == null || !CompareCulture(that))) { return(false); } if ((comparisonFlags & PartialComparisonFlags.PublicKeyToken) != 0 && GetPublicKeyToken() != null && !ComparePublicKeyToken(that)) { return(false); } if (considerRetargetableFlag && (Retargetable != that.Retargetable)) { return(false); } return(true); }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assemblyname of the reference.</param> /// <param name="sdkName">The name of the sdk to resolve.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> abstract public bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile );
/// <summary> /// Unify an assembly name according to the fx retarget rules. /// </summary> /// <param name="assemblyName">The unify-from assembly name.</param> /// <param name="unifiedVersion">The new version number.</param> /// <param name="isPrerequisite">Whether this assembly will be available on target machines.</param> /// <param name="isRedistRoot">May be true, false or null. Null means there was no IsRedistRoot in the redist list.</param> /// <param name="redistName">Name of the corresponding Resist specified in the redist list.</param> internal void GetInfo ( AssemblyNameExtension assemblyName, out Version unifiedVersion, out bool isPrerequisite, out bool? isRedistRoot, out string redistName ) { unifiedVersion = assemblyName.Version; isPrerequisite = false; isRedistRoot = null; redistName = null; // Short-circuit in cases where there is no redist list. if (_redistList == null) { return; } // If there's no version, for example in a simple name, then no remapping is possible, // and this is not a prerequisite. if (assemblyName.Version == null) { return; } AssemblyEntry highestVersionFromRedistList = FindHighestVersionInRedistList(assemblyName); // Could not find the assembly in the redist list. Return as there has been no redist list unification if (highestVersionFromRedistList == null) { return; } // Dont allow downgrading of reference version due to redist unification because this is automatic rather than something like an appconfig which // has to be manually set. However if the major version is 255 then we do want to unify down the version number. if (assemblyName.Version <= highestVersionFromRedistList.AssemblyNameExtension.Version || assemblyName.Version.Major == 255) { unifiedVersion = highestVersionFromRedistList.AssemblyNameExtension.Version; isPrerequisite = _redistList.IsPrerequisiteAssembly(highestVersionFromRedistList.FullName); isRedistRoot = _redistList.IsRedistRoot(highestVersionFromRedistList.FullName); redistName = _redistList.RedistName(highestVersionFromRedistList.FullName); return; } }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assembly name object of the assembly.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> public override bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile ) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { // {GAC} was passed in. string gacResolved = _getAssemblyPathInGac(assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fileExists, fullFusionName: false, specificVersion: wantSpecificVersion); if (!string.IsNullOrEmpty(gacResolved) && fileExists(gacResolved)) { foundPath = gacResolved; return true; } else { // Record this as a location that was considered. if (assembliesConsideredAndRejected != null) { ResolutionSearchLocation considered = new ResolutionSearchLocation(); considered.FileNameAttempted = assemblyName.FullName; considered.SearchPath = searchPathElement; considered.AssemblyName = assemblyName; considered.Reason = NoMatchReason.NotInGac; assembliesConsideredAndRejected.Add(considered); } } } return false; }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assemblyname of the reference.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="candidateAssemblyFiles">List of literal assembly file names to be considered when SearchPaths has {CandidateAssemblyFiles}.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> public override bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile ) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { // {GAC} was passed in. string gacResolved = GlobalAssemblyCache.GetLocation(_buildEngine, assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, false /*may not be a fusion name*/, fileExists, null /*Use default delegate in method*/, null /*Use default delegate in method*/, wantSpecificVersion); if (gacResolved != null && gacResolved.Length > 0 && fileExists(gacResolved)) { foundPath = gacResolved; return true; } else { // Record this as a location that was considered. if (assembliesConsideredAndRejected != null) { ResolutionSearchLocation considered = new ResolutionSearchLocation(); considered.FileNameAttempted = assemblyName.FullName; considered.SearchPath = searchPathElement; considered.AssemblyName = assemblyName; considered.Reason = NoMatchReason.NotInGac; assembliesConsideredAndRejected.Add(considered); } } } return false; }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assemblyname of the reference.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> public override bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile ) { foundPath = null; userRequestedSpecificFile = false; if (rawFileNameCandidate != null) { // {RawFileName} was passed in. if (fileExists(rawFileNameCandidate)) { userRequestedSpecificFile = true; foundPath = rawFileNameCandidate; return true; } else { if (assembliesConsideredAndRejected != null) { ResolutionSearchLocation considered = null; considered = new ResolutionSearchLocation(); considered.FileNameAttempted = rawFileNameCandidate; considered.SearchPath = searchPathElement; considered.Reason = NoMatchReason.NotAFileNameOnDisk; assembliesConsideredAndRejected.Add(considered); } } } return false; }
internal void GetInfo(AssemblyNameExtension assemblyName, out Version unifiedVersion, out bool isPrerequisite, out bool? isRedistRoot, out string redistName) { unifiedVersion = assemblyName.Version; isPrerequisite = false; isRedistRoot = 0; redistName = null; if ((this.redistList != null) && (assemblyName.Version != null)) { AssemblyEntry entry = this.FindHighestVersionInRedistList(assemblyName); if ((entry != null) && (assemblyName.Version <= entry.AssemblyNameExtension.Version)) { unifiedVersion = entry.AssemblyNameExtension.Version; isPrerequisite = this.redistList.IsPrerequisiteAssembly(entry.FullName); isRedistRoot = this.redistList.IsRedistRoot(entry.FullName); redistName = this.redistList.RedistName(entry.FullName); } } }
internal bool CompareCulture(AssemblyNameExtension that) { System.Globalization.CultureInfo cultureInfo = this.CultureInfo; System.Globalization.CultureInfo invariantCulture = that.CultureInfo; if (cultureInfo == null) { cultureInfo = System.Globalization.CultureInfo.InvariantCulture; } if (invariantCulture == null) { invariantCulture = System.Globalization.CultureInfo.InvariantCulture; } if (cultureInfo.LCID != invariantCulture.LCID) { return(false); } return(true); }
public override bool Resolve(AssemblyNameExtension assemblyName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { AssemblyNameExtension highestVersionInRedist = GetHighestVersionInRedist(this.installedAssemblies, assemblyName); foreach (string str in this.frameworkPaths) { string str2 = base.ResolveFromDirectory(highestVersionInRedist, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, str, assembliesConsideredAndRejected); if (str2 != null) { foundPath = str2; return true; } } } return false; }
/// <summary> /// Clone this assemblyNameExtension /// </summary> internal AssemblyNameExtension Clone() { AssemblyNameExtension newExtension = new AssemblyNameExtension(); if (_asAssemblyName != null) { newExtension._asAssemblyName = (AssemblyName)_asAssemblyName.Clone(); } newExtension._asString = _asString; newExtension._isSimpleName = _isSimpleName; newExtension._hasProcessorArchitectureInFusionName = _hasProcessorArchitectureInFusionName; newExtension._remappedFrom = _remappedFrom; // We are cloning so we can now party on the object even if the parent was immutable newExtension._immutable = false; return(newExtension); }
/// <summary> /// Clone this assemblyNameExtension /// </summary> internal AssemblyNameExtension Clone() { AssemblyNameExtension newExtension = new AssemblyNameExtension(); if (asAssemblyName != null) { newExtension.asAssemblyName = asAssemblyName.CloneIfPossible(); } newExtension.asString = asString; newExtension.isSimpleName = isSimpleName; newExtension.hasProcessorArchitectureInFusionName = hasProcessorArchitectureInFusionName; newExtension.remappedFrom = remappedFrom; // We are cloning so we can now party on the object even if the parent was immutable newExtension.immutable = false; return(newExtension); }
public override bool Resolve(AssemblyNameExtension assemblyName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { this.LazyInitialize(); if (this.wasMatch) { AssemblyFoldersEx ex = new AssemblyFoldersEx(this.registryKeyRoot, this.targetRuntimeVersion, this.registryKeySuffix, this.osVersion, this.platform, this.getRegistrySubKeyNames, this.getRegistrySubKeyDefaultValue, base.targetProcessorArchitecture, this.openBaseKey); string str = null; foreach (string str2 in ex) { string path = base.ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, str2, assembliesConsideredAndRejected); if (path != null) { if (str == null) { str = path; } if ((base.targetProcessorArchitecture != ProcessorArchitecture.MSIL) && (base.targetProcessorArchitecture != ProcessorArchitecture.None)) { foundPath = path; return true; } AssemblyNameExtension extension = base.getAssemblyName(path); if ((extension != null) && ((extension.AssemblyName.ProcessorArchitecture == ProcessorArchitecture.MSIL) || (extension.AssemblyName.ProcessorArchitecture == ProcessorArchitecture.None))) { foundPath = path; return true; } } } if (str != null) { foundPath = str; return true; } } } return false; }
private int CompareBaseNameToImpl(AssemblyNameExtension that) { if (this == that) { return(0); } if ((this.asAssemblyName != null) && (that.asAssemblyName != null)) { if (this.asAssemblyName == that.asAssemblyName) { return(0); } return(string.Compare(this.asAssemblyName.Name, that.asAssemblyName.Name, StringComparison.OrdinalIgnoreCase)); } if ((this.asString != null) && (that.asString != null)) { return(CompareBaseNamesStringWise(this.asString, that.asString)); } return(string.Compare(this.Name, that.Name, StringComparison.OrdinalIgnoreCase)); }
private int CompareBaseNameToImpl(AssemblyNameExtension that) { if (this == that) { return 0; } if ((this.asAssemblyName != null) && (that.asAssemblyName != null)) { if (this.asAssemblyName == that.asAssemblyName) { return 0; } return string.Compare(this.asAssemblyName.Name, that.asAssemblyName.Name, StringComparison.OrdinalIgnoreCase); } if ((this.asString != null) && (that.asString != null)) { return CompareBaseNamesStringWise(this.asString, that.asString); } return string.Compare(this.Name, that.Name, StringComparison.OrdinalIgnoreCase); }
/// <summary> /// Allows the comparison of the culture. /// </summary> internal bool CompareCulture(AssemblyNameExtension that) { // Do the Cultures match? CultureInfo aCulture = CultureInfo; CultureInfo bCulture = that.CultureInfo; if (aCulture == null) { aCulture = CultureInfo.InvariantCulture; } if (bCulture == null) { bCulture = CultureInfo.InvariantCulture; } if (aCulture.LCID != bCulture.LCID) { return(false); } return(true); }
internal static AssemblyNameExtension GetHighestVersionInRedist(InstalledAssemblies installedAssemblies, AssemblyNameExtension assemblyName) { AssemblyNameExtension extension = assemblyName; if ((extension.Version == null) && (installedAssemblies != null)) { AssemblyEntry[] entryArray = installedAssemblies.FindAssemblyNameFromSimpleName(assemblyName.Name); if (entryArray.Length <= 1) { return extension; } for (int i = 0; i < entryArray.Length; i++) { AssemblyNameExtension that = new AssemblyNameExtension(entryArray[i].FullName); if (((that.Version != null) && (that.Version.CompareTo(extension.Version) > 0)) && assemblyName.PartialNameCompare(that, PartialComparisonFlags.PublicKeyToken | PartialComparisonFlags.Culture)) { extension = that; } } } return extension; }
/// <summary> /// Given a strong name, find its path in the GAC. /// </summary> /// <param name="strongName">The strong name.</param> /// <param name="targetProcessorArchitecture">Like x86 or IA64\AMD64.</param> /// <returns>The path to the assembly. Empty if none exists.</returns> private static string GetLocationImpl(AssemblyNameExtension assemblyName, string targetProcessorArchitecture, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntime, FileExists fileExists, GetPathFromFusionName getPathFromFusionName, GetGacEnumerator getGacEnumerator, bool specificVersion) { // Extra checks for PInvoke-destined data. ErrorUtilities.VerifyThrowArgumentNull(assemblyName, "assemblyName"); ErrorUtilities.VerifyThrow(assemblyName.FullName != null, "Got a null assembly name fullname."); string strongName = assemblyName.FullName; if (targetProcessorArchitecture != null && !assemblyName.HasProcessorArchitectureInFusionName) { strongName += ", ProcessorArchitecture=" + targetProcessorArchitecture; } string assemblyPath = String.Empty; // Dictionary sorted by Version in reverse order, this will give the values enumeration the highest runtime version first. SortedDictionary<Version, SortedDictionary<AssemblyNameExtension, string>> assembliesByRuntime = GenerateListOfAssembliesByRuntime(strongName, getRuntimeVersion, targetedRuntime, fileExists, getPathFromFusionName, getGacEnumerator, specificVersion); if (assembliesByRuntime != null) { foreach (SortedDictionary<AssemblyNameExtension, string> runtimeBucket in assembliesByRuntime.Values) { // Grab the first element if there are one or more elements. This will give us the highest version assembly name. if (runtimeBucket.Count > 0) { foreach (KeyValuePair<AssemblyNameExtension, string> kvp in runtimeBucket) { assemblyPath = kvp.Value; break; } if (!String.IsNullOrEmpty(assemblyPath)) { break; } } } } return assemblyPath; }
/// <summary> /// Resolve a reference to a specific file name. /// </summary> /// <param name="assemblyName">The assemblyname of the reference.</param> /// <param name="rawFileNameCandidate">The reference's 'include' treated as a raw file name.</param> /// <param name="isPrimaryProjectReference">Whether or not this reference was directly from the project file (and therefore not a dependency)</param> /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param> /// <param name="executableExtensions">Allowed executable extensions.</param> /// <param name="hintPath">The item's hintpath value.</param> /// <param name="assemblyFolderKey">Like "hklm\Vendor RegKey" as provided to a reference by the <AssemblyFolderKey> on the reference in the project.</param> /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param> /// <param name="foundPath">The path where the file was found.</param> /// <param name="userRequestedSpecificFile">Whether or not the user wanted a specific file (for example, HintPath is a request for a specific file)</param> /// <returns>True if the file was resolved.</returns> public override bool Resolve ( AssemblyNameExtension assemblyName, string sdkName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile ) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { // {AssemblyFolders} was passed in. ICollection assemblyFolders = AssemblyFolder.GetAssemblyFolders(assemblyFolderKey); if (assemblyFolders != null) { foreach (string assemblyFolder in assemblyFolders) { string resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, assemblyFolder, assembliesConsideredAndRejected); if (resolvedPath != null) { foundPath = resolvedPath; return true; } } } } return false; }
internal int CompareTo(AssemblyNameExtension that) { if (this.Equals(that)) { return(0); } int num = this.CompareBaseNameTo(that); if (num != 0) { return(num); } if (!(this.Version != that.Version)) { return(string.Compare(this.FullName, that.FullName, StringComparison.OrdinalIgnoreCase)); } if (this.Version == null) { return(-1); } return(this.Version.CompareTo(that.Version)); }
/// <summary> /// Compare two base names as quickly as possible. /// </summary> /// <param name="that"></param> /// <returns></returns> internal int CompareBaseNameTo(AssemblyNameExtension that) { int result = CompareBaseNameToImpl(that); #if DEBUG // Now, compare to the real value to make sure the result was accurate. AssemblyName a1 = _asAssemblyName; AssemblyName a2 = that._asAssemblyName; if (a1 == null) { a1 = new AssemblyName(_asString); } if (a2 == null) { a2 = new AssemblyName(that._asString); } int baselineResult = String.Compare(a1.Name, a2.Name, StringComparison.OrdinalIgnoreCase); ErrorUtilities.VerifyThrow(result == baselineResult, "Optimized version of CompareBaseNameTo didn't return the same result as the baseline."); #endif return(result); }
internal static string ResolveReference(IEnumerable<Microsoft.Build.Tasks.Resolver[]> jaggedResolvers, AssemblyNameExtension assemblyName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string resolvedSearchPath, out bool userRequestedSpecificFile) { userRequestedSpecificFile = false; resolvedSearchPath = string.Empty; foreach (Microsoft.Build.Tasks.Resolver[] resolverArray in jaggedResolvers) { if (resolverArray == null) { break; } foreach (Microsoft.Build.Tasks.Resolver resolver in resolverArray) { string str; if (resolver.Resolve(assemblyName, rawFileNameCandidate, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, hintPath, assemblyFolderKey, assembliesConsideredAndRejected, out str, out userRequestedSpecificFile)) { resolvedSearchPath = resolver.SearchPath; return str; } } } return null; }
/// <summary> /// Clone this assemblyNameExtension /// </summary> internal AssemblyNameExtension Clone() { AssemblyNameExtension newExtension = new AssemblyNameExtension(); if (asAssemblyName != null) { #if FEATURE_ASSEMBLYNAME_CLONE newExtension.asAssemblyName = (AssemblyName)asAssemblyName.Clone(); #else newExtension.asAssemblyName = new AssemblyName(asAssemblyName.FullName); #endif } newExtension.asString = asString; newExtension.isSimpleName = isSimpleName; newExtension.hasProcessorArchitectureInFusionName = hasProcessorArchitectureInFusionName; newExtension.remappedFrom = remappedFrom; // We are cloning so we can now party on the object even if the parent was immutable newExtension.immutable = false; return(newExtension); }
public override bool Resolve(AssemblyNameExtension assemblyName, string rawFileNameCandidate, bool isPrimaryProjectReference, bool wantSpecificVersion, string[] executableExtensions, string hintPath, string assemblyFolderKey, ArrayList assembliesConsideredAndRejected, out string foundPath, out bool userRequestedSpecificFile) { foundPath = null; userRequestedSpecificFile = false; if (assemblyName != null) { foreach (string str in this.candidateAssemblyFiles) { if (Microsoft.Build.Shared.FileUtilities.HasExtension(str, executableExtensions)) { bool flag2 = false; ResolutionSearchLocation searchLocation = null; if (assembliesConsideredAndRejected != null) { searchLocation = new ResolutionSearchLocation { FileNameAttempted = str, SearchPath = base.searchPathElement }; } if (base.FileMatchesAssemblyName(assemblyName, isPrimaryProjectReference, wantSpecificVersion, false, str, searchLocation)) { flag2 = true; } else if (assembliesConsideredAndRejected != null) { assembliesConsideredAndRejected.Add(searchLocation); } if (flag2) { foundPath = str; return true; } } } } return false; }
internal int CompareBaseNameTo(AssemblyNameExtension that) { return(this.CompareBaseNameToImpl(that)); }
internal bool PartialNameCompare(AssemblyNameExtension that) { return(this.PartialNameCompare(that, PartialComparisonFlags.Default)); }
/// <summary> /// Do a partial comparison between two assembly name extensions. /// Compare the fields of A and B on the following conditions: /// 1) A.Field has a non null value /// 2) The field has been selected in the comparison flags or the default comparison flags are passed in. /// /// If A.Field is null then we will not compare A.Field and B.Field even when the comparison flag is set for that field unless skipNullFields is false. /// </summary> internal bool PartialNameCompare(AssemblyNameExtension that, PartialComparisonFlags comparisonFlags) { return(PartialNameCompare(that, comparisonFlags, false /* do not consider retargetable flag*/)); }
/// <summary> /// Compare the fields of this with that if they are not null. /// </summary> internal bool PartialNameCompare(AssemblyNameExtension that, bool considerRetargetableFlag) { return(PartialNameCompare(that, PartialComparisonFlags.Default, considerRetargetableFlag)); }
/// <summary> /// Compare two assembly names for equality. /// </summary> /// <param name="that"></param> /// <returns></returns> private bool EqualsImpl(AssemblyNameExtension that, bool ignoreVersion, bool considerRetargetableFlag) { // Pointer compare. if (Object.ReferenceEquals(this, that)) { return(true); } // If that is null then this and that are not equal. Also, this would cause a crash on the next line. if (Object.ReferenceEquals(that, null)) { return(false); } // Do both have assembly names? if (_asAssemblyName != null && that._asAssemblyName != null) { // Pointer compare. if (Object.ReferenceEquals(_asAssemblyName, that._asAssemblyName)) { return(true); } } // Do both have strings that equal each-other? if (_asString != null && that._asString != null) { if (_asString == that._asString) { return(true); } // If they weren't identical then they might still differ only by // case. So we can't assume that they don't match. So fall through... } // Do the names match? if (0 != String.Compare(Name, that.Name, StringComparison.OrdinalIgnoreCase)) { return(false); } if (!ignoreVersion && (this.Version != that.Version)) { return(false); } if (!CompareCulture(that)) { return(false); } if (!ComparePublicKeyToken(that)) { return(false); } if (considerRetargetableFlag && this.Retargetable != that.Retargetable) { return(false); } return(true); }
internal bool ComparePublicKeyToken(AssemblyNameExtension that) { byte[] publicKeyToken = this.GetPublicKeyToken(); byte[] bPKT = that.GetPublicKeyToken(); return(ComparePublicKeyTokens(publicKeyToken, bPKT)); }
/// <summary> /// Compare two assembly names for equality ignoring version. /// </summary> /// <param name="that"></param> /// <returns></returns> internal bool EqualsIgnoreVersion(AssemblyNameExtension that) { return(EqualsImpl(that, true, false)); }
/// <summary> /// Compare two assembly names for equality. /// </summary> /// <param name="that"></param> /// <returns></returns> internal bool Equals(AssemblyNameExtension that) { return(EqualsImpl(that, false, false)); }
/// <summary> /// Compare one assembly name to another. /// </summary> /// <param name="that"></param> /// <returns></returns> internal int CompareTo(AssemblyNameExtension that) { return(CompareTo(that, false)); }
/// <summary> /// Add an assemblyNameExtension which represents an assembly name which was mapped to THIS assemblyName. /// </summary> internal void AddRemappedAssemblyName(AssemblyNameExtension extensionToAdd) { ErrorUtilities.VerifyThrow(extensionToAdd.Immutable, "ExtensionToAdd is not immutable"); InitializeRemappedFrom(); _remappedFrom.Add(extensionToAdd); }
/// <summary> /// Attempts to convert an itemSpec and fusionName into an assembly name. /// AssemblyName is left unchanged if conversion wasn't possible. /// </summary> /// <param name="itemSpec"></param> /// <param name="fusionName"></param> /// <param name="assemblyName"></param> private static void TryConvertToAssemblyName(string itemSpec, string fusionName, ref AssemblyNameExtension assemblyName) { // FusionName is used if available. string finalName = fusionName; if (finalName == null || finalName.Length == 0) { // Otherwise, its itemSpec. finalName = itemSpec; } bool pathRooted = false; try { pathRooted = Path.IsPathRooted(finalName); } catch (ArgumentException) { /* Eat this because it has invalid chars in to and cannot be a path, maybe it can be parsed as a fusion name.*/ } if (!pathRooted) { // Now try to convert to an AssemblyName. try { assemblyName = new AssemblyNameExtension(finalName, true /*throw if not valid*/); } catch (System.IO.FileLoadException) { // Not a valid AssemblyName. Maybe its a file name. TryGatherAssemblyNameEssentials(finalName, ref assemblyName); return; } } else { // Maybe the string has a fusion name inside of it. TryGatherAssemblyNameEssentials(finalName, ref assemblyName); } }
/// <summary> /// Given a string that may be a fusion name, try to gather the four essential properties: /// Name /// Version /// PublicKeyToken /// Culture /// </summary> /// <param name="fusionName"></param> /// <param name="assemblyName"></param> private static void TryGatherAssemblyNameEssentials(string fusionName, ref AssemblyNameExtension assemblyName) { int firstComma = fusionName.IndexOf(','); if (firstComma == -1) { return; } string name = fusionName.Substring(0, firstComma); string version = null; string publicKeyToken = null; string culture = null; TryGetAssemblyNameComponent(fusionName, "Version", ref version); TryGetAssemblyNameComponent(fusionName, "PublicKeyToken", ref publicKeyToken); TryGetAssemblyNameComponent(fusionName, "Culture", ref culture); if (version == null || publicKeyToken == null || culture == null) { return; } string newFusionName = String.Format(CultureInfo.InvariantCulture, "{0}, Version={1}, Culture={2}, PublicKeyToken={3}", name, version, culture, publicKeyToken); // Now try to convert to an AssemblyName. try { assemblyName = new AssemblyNameExtension(newFusionName, true /* throw if not valid */); } catch (System.IO.FileLoadException) { // Not a valid AssemblyName. Maybe its a file name. // TryGatherAssemblyNameEssentials return; } }
/// <summary> /// Compare two assembly names and consider the retargetable flag during the comparison /// </summary> internal bool Equals(AssemblyNameExtension that, bool considerRetargetableFlag) { return(EqualsImpl(that, false, considerRetargetableFlag)); }