internal string GetAssemblyPath(AssemblyName assemblyName) { if (IsFailedAssembly(assemblyName.FullName)) { return string.Empty; } string filePath = string.Empty; if (string.IsNullOrEmpty(filePath)) { IEnumerable<string> filePaths = GetAssemblyPaths(assemblyName); filePath = filePaths.FirstOrDefault() ?? string.Empty; if (string.IsNullOrEmpty(filePath)) { foreach (string currentFilePath in filePaths) { if (!string.IsNullOrEmpty(currentFilePath)) { filePath = currentFilePath; break; } } } if (CheckFoundedAssembly(assemblyName, filePath)) { return filePath; } } return filePath; }
private bool AreDefaultDirEqual(AssemblyName assemblyName, AssemblyName assemblyNameFromStorage) { if (!assemblyName.HasDefaultDir && !assemblyNameFromStorage.HasDefaultDir) { return true; } if (assemblyName.HasDefaultDir && assemblyNameFromStorage.HasDefaultDir) { if (File.Exists(Path.Combine(assemblyName.DefaultDir, assemblyName.Name + ".dll")) && File.Exists(Path.Combine(assemblyNameFromStorage.DefaultDir, assemblyNameFromStorage.Name + ".dll"))) { return assemblyName.DefaultDir == assemblyNameFromStorage.DefaultDir; } return true; } return true; }
private IEnumerable<string> ResolveWinRTMetadata(AssemblyName assemblyName) { string filePath = string.Format(@"{0}\{1}.winmd", SystemInformation.WINRT_METADATA, assemblyName.Name); if (CheckFileExistence(assemblyName, filePath, true, false)) { yield return filePath; } if (!Directory.Exists(SystemInformation.WINDOWS_WINMD_LOCATION)) { yield break; } foreach (string foundFile in Directory.GetFiles(SystemInformation.WINDOWS_WINMD_LOCATION, assemblyName.Name + ".winmd", SearchOption.AllDirectories)) { if (CheckFileExistence(assemblyName, foundFile, true, false)) { yield return foundFile; } } }
public override string FindAssemblyPath(AssemblyName assemblyName, string fallbackDir, bool bubbleToUserIfFailed = true) { return base.FindAssemblyPath(assemblyName, fallbackDir, bubbleToUserIfFailed: false); }
public string ResolveAssemblyPath(string strongName) { AssemblyNameReference nameRef = AssemblyNameReference.Parse(strongName); TargetArchitecture architecture = GetArchitectureFromStrongName(strongName); AssemblyName assemblyName = new AssemblyName(nameRef.Name, nameRef.FullName, nameRef.Version, nameRef.PublicKeyToken) { TargetArchitecture = architecture }; IEnumerable<string> files = assemblyPathResolver.GetAssemblyPaths(assemblyName); foreach (string file in files) { if (GetAssemblyDefinition(file).main_module.GetModuleArchitecture().CanReference(architecture)) { return file; } } return string.Empty; }
private bool TrySearchDirectory(AssemblyNameReference name, ReaderParameters parameters, TargetArchitecture architecture, IEnumerable<DirectoryAssemblyInfo> targetDirs, out AssemblyDefinition assemblyDefinition) { assemblyDefinition = null; string lowerName = name.Name.ToLowerInvariant(); foreach (DirectoryAssemblyInfo directoryAssembly in targetDirs) { string assemblyPath = directoryAssembly.FullFileName; if (directoryAssembly.FileNameWithoutExtension == lowerName) { AssemblyName assName = new AssemblyName(name.Name, name.FullName, name.Version, name.PublicKeyToken) { TargetArchitecture = architecture }; bool sameVersion = assemblyPathResolver.CheckFileExistence(assName, assemblyPath, false, false, checkForArchitectPlatfrom: true); if (sameVersion) { assemblyDefinition = GetAssembly(directoryAssembly.FullFileName, parameters); return true; } } } return false; }
/*Telerik Authorship*/ private AssemblyDefinition GetFromResolvedAssemblies(AssemblyName assemblyName) { string extendedKey = assemblyName.FullName + ",Architecture="; foreach (string architectureString in GetReferencableArchitectures(assemblyName)) { List<AssemblyDefinition> assemblyList; if (TryGetResolvedAssembly(extendedKey + architectureString, out assemblyList)) { return assemblyList[0]; } } return null; }
private IEnumerable<string> ResolveSilverlightPaths(AssemblyName assemblyName) { List<string> result = new List<string>(); string runtime = ResolveSilverlightRuntimePath(assemblyName, SystemInformation.SILVERLIGHT_RUNTIME); string runtime64 = ResolveSilverlightRuntimePath(assemblyName, SystemInformation.SILVERLIGHT_RUNTIME_64); IEnumerable<string> @default = ResolveSilverlightPath(assemblyName, SystemInformation.SILVERLIGHT_DEFAULT); IEnumerable<string> sdk = ResolveSilverlightPath(assemblyName, SystemInformation.SILVERLIGHT_SDK); if (string.IsNullOrEmpty(runtime) == false) { result.Add(runtime); } result.AddRange(@default); result.AddRange(sdk); /*Telerik Authorship*/ if (string.IsNullOrEmpty(runtime64) == false) { result.Add(runtime64); } return result; }
private string ResolveSilverlightRuntimePath(AssemblyName assemblyName, string path) { string searchPattern = string.Format(path, assemblyName.Name); if (CheckFileExistence(assemblyName, searchPattern, true, true)) { return searchPattern; } return string.Empty; }
public IEnumerable<string> GetAssemblyPaths(AssemblyName sourceAssemblyName) { IEnumerable<string> results; if (TryGetAssemblyPathsFromCache(sourceAssemblyName, out results)) { return results; } if (IsFailedAssembly(sourceAssemblyName.FullName)) { return Enumerable.Empty<string>(); } var platforms = new List<TargetPlatform> { TargetPlatform.CLR_4, TargetPlatform.CLR_2_3, TargetPlatform.Silverlight, TargetPlatform.WindowsPhone, TargetPlatform.WindowsCE, TargetPlatform.CLR_1, TargetPlatform.WinRT }; var result = new List<string>(); foreach (TargetPlatform platform in platforms) { IEnumerable<string> assemblyLocations = GetAssemblyLocationsByPlatform(sourceAssemblyName, platform); result.AddRange(assemblyLocations); } return result; }
private IEnumerable<string> GetAssemblyLocationsByPlatform(AssemblyName assemblyName, TargetPlatform runtime) { var result = new List<string>(); switch (runtime) { case TargetPlatform.CLR_1: result.AddRange(ResolveClr1(assemblyName)); break; case TargetPlatform.CLR_2_3: case TargetPlatform.CLR_4: result.AddRange(ResolveClr(assemblyName, runtime)); break; case TargetPlatform.WindowsCE: result.AddRange(ResolveCompact(assemblyName)); break; case TargetPlatform.Silverlight: case TargetPlatform.WindowsPhone: result.AddRange(ResolveSilverlightPaths(assemblyName)); result.AddRange(ResolveWP(assemblyName)); break; case TargetPlatform.WinRT: result.AddRange(ResolveWinRTMetadata(assemblyName)); break; } AddPartCacheResult(result, runtime); return result; }
internal bool TryGetAssemblyPathsFromCache(AssemblyName sourceAssemblyName, out IEnumerable<string> filePaths) { filePaths = Enumerable.Empty<string>(); if (pathRepository.AssemblyPathName.ContainsKey(sourceAssemblyName.FullName)) { List<string> targets = pathRepository.AssemblyPathName.Where(a => a.Key == sourceAssemblyName.FullName) .Select(a => a.Value) .ToList(); if (sourceAssemblyName.HasDefaultDir && targets.Any(d => Path.GetDirectoryName(d) == sourceAssemblyName.DefaultDir)) { filePaths = targets.Where(d => Path.GetDirectoryName(d) == sourceAssemblyName.DefaultDir); return true; } else { string targetAssembly = pathRepository.AssemblyPathName .Where(a => pathRepository.AssemblyPathArchitecture.ContainsKey(a.Value) && pathRepository.AssemblyPathArchitecture[a.Value].CanReference(sourceAssemblyName.TargetArchitecture)) .FirstOrDefault(a => a.Key == sourceAssemblyName.FullName).Value; if (targetAssembly != null) { filePaths = new string[] { targetAssembly }; return true; } } } return false; }
private bool CheckFoundedAssembly(AssemblyName assemblyName, string filePath) { bool checkFileExistence = CheckFileExistence(assemblyName, filePath, false, false); return checkFileExistence; }
public bool CheckFileExistence(AssemblyName assemblyName, string searchPattern, bool caching, bool checkForBaseDir, bool checkForArchitectPlatfrom = true) { AssemblyName assemblyNameFromStorage; if (TryGetAssemblyNameDefinition(searchPattern, caching, assemblyName.TargetArchitecture, out assemblyNameFromStorage, checkForArchitectPlatfrom)) { var areEquals = AreVersionEquals(assemblyNameFromStorage.Version, assemblyName.Version) && ArePublicKeyEquals(assemblyNameFromStorage.PublicKeyToken, assemblyName.PublicKeyToken) && assemblyName.TargetArchitecture.CanReference(assemblyNameFromStorage.TargetArchitecture) && (!checkForBaseDir || AreDefaultDirEqual(assemblyName, assemblyNameFromStorage)); if (areEquals && caching) { pathRepository.AssemblyPathName.Add(assemblyName.FullName, searchPattern); if (!pathRepository.AssemblyPathArchitecture.ContainsKey(searchPattern)) { TargetArchitecture architecture = AssemblyDefinition.ReadAssembly(searchPattern, readerParameters).MainModule.GetModuleArchitecture(); pathRepository.AssemblyPathArchitecture.Add(new KeyValuePair<string, TargetArchitecture>(searchPattern, architecture)); } } return areEquals; } return false; }
private bool TryGetAssemblyNameDefinition(string assemblyFilePath, bool caching, TargetArchitecture architecture, out AssemblyName assemblyName, bool checkForArchitectPlatfrom = true) { assemblyName = null; if (pathRepository.AssemblyNameDefinition.ContainsKey(assemblyFilePath)) { assemblyName = pathRepository.AssemblyNameDefinition[assemblyFilePath]; if (!checkForArchitectPlatfrom) { return true; } else if (assemblyName.TargetArchitecture == architecture) { return true; } } if ((caching || assemblyName == null) && File.Exists(assemblyFilePath)) { var moduleDef = ModuleDefinition.ReadModule(assemblyFilePath, readerParameters); if (moduleDef != null && moduleDef.Assembly != null) { AssemblyDefinition assemblyDef = moduleDef.Assembly; assemblyName = new AssemblyName(moduleDef.Name, assemblyDef.FullName, assemblyDef.Name.Version, assemblyDef.Name.PublicKeyToken, Path.GetDirectoryName(assemblyFilePath)) { TargetArchitecture = moduleDef.GetModuleArchitecture() }; pathRepository.AssemblyNameDefinition[assemblyFilePath] = assemblyName; return true; } } return false; }
private IEnumerable<string> ResolveSilverlightPath(AssemblyName assemblyName, string path) { foreach (var version in assemblyName.SupportedVersions(TargetPlatform.Silverlight)) { string searchPattern = string.Format(path, SystemInformation.ProgramFilesX86, version, assemblyName.Name); if (CheckFileExistence(assemblyName, searchPattern, true, true)) { yield return searchPattern; } } }
internal void AddToAssemblyPathNameCache(AssemblyName assemblyName, string filePath) { pathRepository.AssemblyPathName.Add(assemblyName.FullName, filePath); if (!pathRepository.AssemblyPathArchitecture.ContainsKey(filePath)) { pathRepository.AssemblyPathArchitecture.Add(new KeyValuePair<string, TargetArchitecture>(filePath, assemblyName.TargetArchitecture)); } }
private IEnumerable<string> ResolveCompact(AssemblyName assemblyName) { foreach (var ver in assemblyName.SupportedVersions(TargetPlatform.WindowsCE)) { var searchPattern = string.Format(SystemInformation.COMPACT_FRAMEWORK, SystemInformation.ProgramFilesX86, ver, assemblyName.Name); if (CheckFileExistence(assemblyName, searchPattern, true, false)) { yield return searchPattern; } } }
protected ProjectItemGroup CreatePojectReferences(ModuleDefinition module, ProjectPropertyGroup basicProjectProperties) { ProjectItemGroup result = new ProjectItemGroup(); ICollection<AssemblyNameReference> dependingOnAssemblies = GetAssembliesDependingOn(module); result.Reference = new ProjectItemGroupReference[dependingOnAssemblies.Count]; string copiedReferencesSubfolder = basicProjectProperties.AssemblyName + "References"; string referencesPath = TargetPath.Remove(TargetPath.LastIndexOf(Path.DirectorySeparatorChar)) + Path.DirectorySeparatorChar + copiedReferencesSubfolder; int assemblyReferenceIndex = 0; foreach (AssemblyNameReference reference in dependingOnAssemblies) { if (reference.Name == "mscorlib" || reference.Name == "Windows" && reference.Version.Equals(new Version(255, 255, 255, 255)) || reference.Name == "System.Runtime") { continue; } AssemblyName assemblyName = new AssemblyName(reference.Name, reference.FullName, reference.Version, reference.PublicKeyToken); string currentReferenceInitialLocation = this.currentAssemblyResolver.FindAssemblyPath(assemblyName, null); AssemblyDefinition referencedAssembly = this.currentAssemblyResolver.Resolve(reference, "", assembly.MainModule.GetModuleArchitecture()); #if NET35 if (!currentReferenceInitialLocation.IsNullOrWhiteSpace()) #else if (!string.IsNullOrWhiteSpace(currentReferenceInitialLocation)) #endif { result.Reference[assemblyReferenceIndex] = new ProjectItemGroupReference(); if (IsInReferenceAssemblies(referencedAssembly)) { //TODO: Consider doing additional check, to see if the assembly is resolved because it was pointed by the used/already in the tree // In this case, it might be better to copy it. result.Reference[assemblyReferenceIndex].Include = reference.Name; } else // Copy the referenced assembly { if (!Directory.Exists(referencesPath)) { Directory.CreateDirectory(referencesPath); } string currentReferenceFileName = Path.GetFileName(currentReferenceInitialLocation); string currentReferenceFinalLocation = Path.Combine(referencesPath, currentReferenceFileName); File.Copy(currentReferenceInitialLocation, currentReferenceFinalLocation, true); // set to normal for testing purposes- to allow the test project to delete the coppied file between test runs File.SetAttributes(currentReferenceFinalLocation, FileAttributes.Normal); string relativePath = Path.Combine(".", copiedReferencesSubfolder); relativePath = Path.Combine(relativePath, currentReferenceFileName); result.Reference[assemblyReferenceIndex].Include = Path.GetFileNameWithoutExtension(currentReferenceFinalLocation); result.Reference[assemblyReferenceIndex].Item = relativePath; } } assemblyReferenceIndex++; } ICollection<ModuleReference> dependingOnModules = GetModulesDependingOn(module); result.AddModules = new ProjectItemGroupAddModules[dependingOnModules.Count * 2]; int moduleReferenceIndex = 0; foreach (ModuleReference moduleRef in dependingOnModules) { result.AddModules[moduleReferenceIndex] = new ProjectItemGroupAddModules(); result.AddModules[moduleReferenceIndex].Include = @"bin\Debug\" + Utilities.GetNetmoduleName(moduleRef) + ".netmodule"; result.AddModules[moduleReferenceIndex].Condition = " '$(Configuration)' == 'Debug' "; moduleReferenceIndex++; result.AddModules[moduleReferenceIndex] = new ProjectItemGroupAddModules(); result.AddModules[moduleReferenceIndex].Include = @"bin\Release\" + Utilities.GetNetmoduleName(moduleRef) + ".netmodule"; result.AddModules[moduleReferenceIndex].Condition = " '$(Configuration)' == 'Release' "; moduleReferenceIndex++; } return result; }
private IEnumerable<string> ResolveWP(AssemblyName assemblyName) { foreach (var version in assemblyName.SupportedVersions(TargetPlatform.WindowsPhone)) { string windowsPhoneDir = string.Format(@"{0}\Reference Assemblies\Microsoft\Framework\Silverlight\{1}\Profile\", SystemInformation.ProgramFilesX86, version); if (Directory.Exists(windowsPhoneDir)) { foreach (string dirVersions in Directory.GetDirectories(windowsPhoneDir, "WindowsPhone*.")) { string searchPattern = string.Format("{0}\\{1}.dll", dirVersions, assemblyName.Name); if (CheckFileExistence(assemblyName, searchPattern, true, true)) { yield return searchPattern; } } } } }
private string[] GetReferencableArchitectures(AssemblyName assemblyName) { if (assemblyName.TargetArchitecture != TargetArchitecture.AnyCPU) { return new string[] { "AnyCPU", assemblyName.TargetArchitecture.ToString() }; } return architectureStrings; }
private IEnumerable<string> ResolveClr(AssemblyName assemblyName, TargetPlatform clrRuntime) { var result = new List<string>(); string versionMajor = string.Format("v{0}*", (clrRuntime == TargetPlatform.CLR_4 ? 4 : 2)); var targetDirectories = new List<string>(); if (Directory.Exists(SystemInformation.CLR_Default_32)) { targetDirectories.AddRange(Directory.GetDirectories(SystemInformation.CLR_Default_32, versionMajor)); } if (Directory.Exists(SystemInformation.CLR_Default_64)) { targetDirectories.AddRange(Directory.GetDirectories(SystemInformation.CLR_Default_64, versionMajor)); } foreach (var dir in targetDirectories) { foreach (string extension in SystemInformation.ResolvableExtensions) { string filePath = dir + "\\" + assemblyName.Name + extension; if (CheckFileExistence(assemblyName, filePath, true, false)) { result.Add(filePath); } } } var searchPattern = clrRuntime == TargetPlatform.CLR_4 ? SystemInformation.CLR_4 : SystemInformation.CLR; foreach (var targetRuntime in assemblyName.SupportedVersions(clrRuntime)) { foreach (var extension in SystemInformation.ResolvableExtensions) { string filePath = string.Format(searchPattern, SystemInformation.WindowsPath, targetRuntime, assemblyName.Name, assemblyName.ParentDirectory(clrRuntime), assemblyName.Name, extension); if (CheckFileExistence(assemblyName, filePath, true, false)) { result.Add(filePath); } } } return result; }
AssemblyDefinition TryGetTargetAssembly(AssemblyNameReference reference, ReaderParameters parameters, TargetArchitecture architecture) { if (reference == null) { return null; } var assemblyName = new AssemblyName(reference.Name, reference.FullName, reference.Version, reference.PublicKeyToken) { TargetArchitecture = architecture }; IEnumerable<string> filePaths; if (assemblyPathResolver.TryGetAssemblyPathsFromCache(assemblyName, out filePaths)) { return GetTargetAssembly(filePaths, parameters, architecture); } return null; }
private IEnumerable<string> ResolveClr1(AssemblyName assemblyName) { string path = Path.Combine(SystemInformation.WindowsPath, "Microsoft.NET\\Framework"); if (assemblyName.Version.Major != 1) { yield break; } foreach (string extension in SystemInformation.ResolvableExtensions) { string[] files = Directory.GetFiles(path, assemblyName.Name + extension, SearchOption.AllDirectories); foreach (string filePath in files) { if (CheckFileExistence(assemblyName, filePath, true, false)) { yield return filePath; } } } }
public virtual string FindAssemblyPath(AssemblyName assemblyName, string fallbackDir, bool bubbleToUserIfFailed = true) { if (assemblyPathResolver.IsFailedAssembly(assemblyName.FullName)) { return null; } AssemblyDefinition resolvedAssembly = GetFromResolvedAssemblies(assemblyName); if (resolvedAssembly != null) { return resolvedAssembly.MainModule.FilePath; } var assemblyNameRef = new AssemblyNameReference(assemblyName.Name, assemblyName.Version) { PublicKeyToken = assemblyName.PublicKeyToken }; IEnumerable<string> results; if (assemblyPathResolver.TryGetAssemblyPathsFromCache(assemblyName, out results)) { return results.FirstOrDefault(); } AssemblyDefinition assembluDefinition = SearchDirectory(assemblyNameRef, new ReaderParameters(this), assemblyName.TargetArchitecture, fallbackDir); if (assembluDefinition != null) { assemblyPathResolver.AddToAssemblyPathNameCache(assemblyName, assembluDefinition.MainModule.FilePath); return assembluDefinition.MainModule.FilePath; } string result = assemblyPathResolver.GetAssemblyPath(assemblyName); #if !NET_4_0 if (!result.IsNullOrWhiteSpace()) #else if (!string.IsNullOrWhiteSpace(result)) #endif { return result; } if (bubbleToUserIfFailed) { assembluDefinition = UserSpecifiedAssembly(assemblyNameRef, assemblyName.TargetArchitecture); } if (assembluDefinition != null) { string filePath = assembluDefinition.MainModule.FilePath; this.AddSearchDirectory(Path.GetDirectoryName(filePath)); return filePath; } return result; }
private IEnumerable<string> ResolveUWPReferences(AssemblyName assemblyName) { string fileName = string.Format("{0}.winmd", assemblyName.Name); string filePath = Path.Combine(SystemInformation.UWP_REFERENCES, assemblyName.Name, assemblyName.Version.ToString(), fileName); if (CheckFileExistence(assemblyName, filePath, true, false)) { yield return filePath; } }