/*Telerik Authorship*/
public string ResolveAssemblyPath(string strongName, SpecialTypeAssembly special)
{
AssemblyNameReference nameRef = AssemblyNameReference.Parse(strongName);
TargetArchitecture architecture = GetArchitectureFromStrongName(strongName);
AssemblyName assemblyName = new AssemblyName(nameRef.Name,
nameRef.FullName,
nameRef.Version,
nameRef.PublicKeyToken)
{
TargetArchitecture = architecture
};
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(assemblyName.FullName, architecture, special);
IEnumerable <string> files = assemblyPathResolver.GetAssemblyPaths(assemblyName, assemblyKey);
foreach (string file in files)
{
if (GetAssemblyDefinition(file).main_module.GetModuleArchitecture().CanReference(architecture))
{
return(file);
}
}
return(string.Empty);
}
protected override bool TryGetResolvedAssembly(AssemblyStrongNameExtended assemblyKey, out List <AssemblyDefinition> assemblyList)
{
lock (this.resolvedAssembliesAccessLock)
{
return(base.TryGetResolvedAssembly(assemblyKey, out assemblyList));
}
}
protected override void RemoveFromResolvedAssemblies(AssemblyStrongNameExtended assemblyKey)
{
lock (this.resolvedAssembliesAccessLock)
{
base.RemoveFromResolvedAssemblies(assemblyKey);
}
}
protected override void AddToResolvedAssembliesInternal(AssemblyStrongNameExtended assemblyKey, List <AssemblyDefinition> assemblyList)
{
lock (this.resolvedAssembliesAccessLock)
{
base.AddToResolvedAssembliesInternal(assemblyKey, assemblyList);
}
}
public bool Equals(AssemblyStrongNameExtended other)
{
if (other == null)
{
return(false);
}
return(this.StrongName == other.StrongName && this.Architecture == other.Architecture && this.Special == other.Special);
}
protected override void CreateProjectReferenceInternal(ModuleDefinition module, AssemblyNameReference reference, ref int assemblyReferenceIndex, SpecialTypeAssembly special, string referencesPath, string copiedReferencesSubfolder)
{
AssemblyName assemblyName = new AssemblyName(reference.Name,
reference.FullName,
reference.Version,
reference.PublicKeyToken);
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(assemblyName.FullName, module.Architecture, special);
string currentReferenceInitialLocation = this.currentAssemblyResolver.FindAssemblyPath(assemblyName, null, assemblyKey);
AssemblyDefinition referencedAssembly = this.currentAssemblyResolver.Resolve(reference, "", assembly.MainModule.GetModuleArchitecture(), special);
#if NET35
if (!currentReferenceInitialLocation.IsNullOrWhiteSpace())
#else
if (!string.IsNullOrWhiteSpace(currentReferenceInitialLocation))
#endif
{
if (!this.IsInDotNetAssemblies(referencedAssembly))
{
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);
this.ProjectFileManager.AddReferenceProjectItem(
assemblyReferenceIndex,
Path.GetFileNameWithoutExtension(currentReferenceFinalLocation),
relativePath);
}
}
else
{
if (this.IsAspNetAssembly(reference))
{
this.ProjectFileManager.AddPackageReferenceProjectItem(reference.Name, reference.Version.ToString());
}
else
{
this.ProjectFileManager.AddReferenceProjectItem(assemblyReferenceIndex, reference.FullName);
}
}
}
protected virtual void CreateProjectReferenceInternal(ModuleDefinition module, AssemblyNameReference reference, ref int assemblyReferenceIndex,
SpecialTypeAssembly special, string referencesPath, string copiedReferencesSubfolder)
{
AssemblyName assemblyName = new AssemblyName(reference.Name,
reference.FullName,
reference.Version,
reference.PublicKeyToken);
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(assemblyName.FullName, module.Architecture, special);
string currentReferenceInitialLocation = this.currentAssemblyResolver.FindAssemblyPath(assemblyName, null, assemblyKey);
AssemblyDefinition referencedAssembly = this.currentAssemblyResolver.Resolve(reference, "", assembly.MainModule.GetModuleArchitecture(), special);
#if NET35
if (!currentReferenceInitialLocation.IsNullOrWhiteSpace())
#else
if (!string.IsNullOrWhiteSpace(currentReferenceInitialLocation))
#endif
{
if (this.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.
this.projectFileManager.AddReferenceProjectItem(assemblyReferenceIndex, 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);
this.projectFileManager.AddReferenceProjectItem(
assemblyReferenceIndex,
Path.GetFileNameWithoutExtension(currentReferenceFinalLocation),
relativePath);
}
}
else
{
this.projectFileManager.AddReferenceProjectItem(assemblyReferenceIndex, reference.FullName);
}
}
/*Telerik Authorship*/
private AssemblyDefinition GetFromResolvedAssemblies(AssemblyName assemblyName, SpecialTypeAssembly special)
{
foreach (string architectureString in GetReferencableArchitectures(assemblyName))
{
List <AssemblyDefinition> assemblyList;
AssemblyStrongNameExtended extendedStrongName = new AssemblyStrongNameExtended(assemblyName.FullName, (TargetArchitecture)Enum.Parse(typeof(TargetArchitecture), architectureString), special);
if (TryGetResolvedAssembly(extendedStrongName, out assemblyList))
{
return(assemblyList[0]);
}
}
return(null);
}
private void AddToResolvedAssemblies(AssemblyDefinition assemblyDef)
{
filePathToAssemblyDefinitionCache.Add(assemblyDef.MainModule.FilePath, assemblyDef);
/*Telerik Authorship*/
AssemblyStrongNameExtended assemblyKey = GetAssemblyKey(assemblyDef);
List <AssemblyDefinition> assemblyList;
if (!TryGetResolvedAssembly(assemblyKey, out assemblyList))
{
assemblyList = new List <AssemblyDefinition>();
AddToResolvedAssembliesInternal(assemblyKey, assemblyList);
}
assemblyList.Add(assemblyDef);
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
AssemblyStrongNameExtended other = obj as AssemblyStrongNameExtended;
return(this.Equals(other));
}
private bool TryResolveTypeAssemblyFilePath(TypeReference typeReference, out string assemblyFilePath)
{
ModuleDefinition moduleDefinition = typeReference.Module;
AssemblyNameReference assemblyNameReference = typeReference.Module.Assembly.Name;
AssemblyStrongNameExtended assemblyKey = this.GetExtendedStrongName(moduleDefinition);
AssemblyName assemblyName = new AssemblyName(assemblyNameReference.Name,
assemblyNameReference.FullName,
assemblyNameReference.Version,
assemblyNameReference.PublicKeyToken)
{
TargetArchitecture = moduleDefinition.GetModuleArchitecture()
};
assemblyFilePath = moduleDefinition.AssemblyResolver.FindAssemblyPath(assemblyName, null, assemblyKey);
return(!string.IsNullOrEmpty(assemblyFilePath));
}
protected override void AddToResolvedAssembliesInternal(AssemblyStrongNameExtended assemblyKey, List <AssemblyDefinition> assemblyList)
{
V_0 = this.resolvedAssembliesAccessLock;
V_1 = false;
try
{
Monitor.Enter(V_0, ref V_1);
this.AddToResolvedAssembliesInternal(assemblyKey, assemblyList);
}
finally
{
if (V_1)
{
Monitor.Exit(V_0);
}
}
return;
}
protected override void RemoveFromResolvedAssemblies(AssemblyStrongNameExtended assemblyKey)
{
V_0 = this.resolvedAssembliesAccessLock;
V_1 = false;
try
{
Monitor.Enter(V_0, ref V_1);
this.RemoveFromResolvedAssemblies(assemblyKey);
}
finally
{
if (V_1)
{
Monitor.Exit(V_0);
}
}
return;
}
protected override bool TryGetResolvedAssembly(AssemblyStrongNameExtended assemblyKey, out List <AssemblyDefinition> assemblyList)
{
V_0 = this.resolvedAssembliesAccessLock;
V_1 = false;
try
{
Monitor.Enter(V_0, ref V_1);
V_2 = this.TryGetResolvedAssembly(assemblyKey, ref assemblyList);
}
finally
{
if (V_1)
{
Monitor.Exit(V_0);
}
}
return(V_2);
}
AssemblyDefinition GetTargetAssembly(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
};
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(assemblyName.FullName, architecture, SpecialTypeAssembly.None);
IEnumerable <string> filePaths = assemblyPathResolver.GetAssemblyPaths(assemblyName, assemblyKey);
return(GetTargetAssembly(filePaths, parameters, architecture));
}
/*Telerik Authorship*/
public virtual void AddToAssemblyCache(string filePath, TargetArchitecture platform, bool storeAssemblyDefInCahce = false)
{
assemblyPathResolver.AddToAssemblyCache(filePath, platform);
AddSearchDirectory(Path.GetDirectoryName(filePath));
if (storeAssemblyDefInCahce && !filePathToAssemblyDefinitionCache.ContainsKey(filePath))
{
AssemblyDefinition assemblyDef = LoadAssemblyDefinition(filePath, new ReaderParameters(this), loadPdb: true);
if (assemblyDef != null)
{
string strongName = assemblyDef.MainModule.Name;
TargetArchitecture architecture = assemblyDef.MainModule.Architecture;
SpecialTypeAssembly special = assemblyDef.MainModule.IsReferenceAssembly() ? SpecialTypeAssembly.Reference : SpecialTypeAssembly.None;
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(strongName, architecture, special);
AddToResolvedAssemblies(assemblyDef);
assemblyPathResolver.RemoveFromUnresolvedCache(assemblyKey);
}
}
}
public void RemoveFromAssemblyCache(string fileName)
{
assemblyPathResolver.RemoveFromAssemblyCache(fileName);
AssemblyDefinition assemblyDef;
if (filePathToAssemblyDefinitionCache.TryGetValue(fileName, out assemblyDef))
{
/*Telerik Authorship*/
AssemblyStrongNameExtended assemblyKey = GetAssemblyKey(assemblyDef);
List <AssemblyDefinition> assemblyDefinitions;
if (TryGetResolvedAssembly(assemblyKey, out assemblyDefinitions))
{
assemblyDefinitions.Remove(assemblyDef);
if (assemblyDefinitions.Count == 0)
{
RemoveFromResolvedAssemblies(assemblyKey);
}
}
filePathToAssemblyDefinitionCache.Remove(fileName);
}
}
/*Telerik Authorship*/
private AssemblyDefinition UserSpecifiedAssembly(AssemblyNameReference name, TargetArchitecture architecture, AssemblyStrongNameExtended assemblyKey)
{
//If not in denied assemblies cache
if (assemblyPathResolver.IsFailedAssembly(assemblyKey))
{
return(null);
}
if (ResolveFailure != null)
{
AssemblyDefinition assembly = ResolveFailure(this, new AssemblyResolveEventArgs(name, architecture));
if (assembly != null)
{
if (!filePathToAssemblyDefinitionCache.ContainsKey(assembly.MainModule.FilePath))
{
AddToResolvedAssemblies(assembly);
}
if (!userDefinedAssemblies.Contains(assembly.MainModule.FilePath))
{
userDefinedAssemblies.Add(assembly.MainModule.FilePath);
}
RemoveFromFailedAssemblies(assemblyKey);
return(assembly);
}
}
assemblyPathResolver.AddToUnresolvedCache(assemblyKey);
return(null);
}
public override string FindAssemblyPath(AssemblyName assemblyName, string fallbackDir, AssemblyStrongNameExtended assemblyKey, bool bubbleToUserIfFailed = true)
{
return(base.FindAssemblyPath(assemblyName, fallbackDir, assemblyKey, bubbleToUserIfFailed: false));
}
/*Telerik Authorship*/
protected virtual void RemoveFromResolvedAssemblies(AssemblyStrongNameExtended assemblyKey)
{
resolvedAssemblies.Remove(assemblyKey);
}
/*Telerik Authorship*/
public virtual string FindAssemblyPath(AssemblyName assemblyName, string fallbackDir, AssemblyStrongNameExtended assemblyKey, bool bubbleToUserIfFailed = true)
{
if (assemblyPathResolver.IsFailedAssembly(assemblyKey))
{
return(null);
}
AssemblyDefinition resolvedAssembly = GetFromResolvedAssemblies(assemblyName, SpecialTypeAssembly.None);
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, assemblyKey, out results))
{
return(results.FirstOrDefault());
}
AssemblyDefinition assemblyDefinition = SearchDirectory(assemblyNameRef, new ReaderParameters(this), assemblyName.TargetArchitecture, fallbackDir);
if (assemblyDefinition != null)
{
assemblyPathResolver.AddToAssemblyPathNameCache(assemblyName, assemblyDefinition.MainModule.FilePath);
return(assemblyDefinition.MainModule.FilePath);
}
string result = assemblyPathResolver.GetAssemblyPath(assemblyName, assemblyKey);
#if !NET_4_0
if (!result.IsNullOrWhiteSpace())
#else
if (!string.IsNullOrWhiteSpace(result))
#endif
{
return(result);
}
if (bubbleToUserIfFailed)
{
assemblyDefinition = UserSpecifiedAssembly(assemblyNameRef, assemblyName.TargetArchitecture, assemblyKey);
}
if (assemblyDefinition != null)
{
string filePath = assemblyDefinition.MainModule.FilePath;
this.AddSearchDirectory(Path.GetDirectoryName(filePath));
return(filePath);
}
return(result);
}
AssemblyDefinition TryGetTargetAssembly(AssemblyNameReference reference, ReaderParameters parameters, TargetArchitecture architecture, AssemblyStrongNameExtended assemblyKey)
{
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, assemblyKey, out filePaths))
{
return(GetTargetAssembly(filePaths, parameters, architecture));
}
return(null);
}
/*Telerik Authorship*/
public void RemoveFromFailedAssemblies(AssemblyStrongNameExtended assemblyName)
{
assemblyPathResolver.RemoveFromUnresolvedCache(assemblyName);
}
/*Telerik Authorship*/
protected virtual bool TryGetResolvedAssembly(AssemblyStrongNameExtended key, out List <AssemblyDefinition> assemblyList)
{
return(resolvedAssemblies.TryGetValue(key, out assemblyList));
}
/*Telerik Authorship*/
protected virtual void AddToResolvedAssembliesInternal(AssemblyStrongNameExtended assemblyKey, List <AssemblyDefinition> assemblyList)
{
resolvedAssemblies.Add(assemblyKey, assemblyList);
}
/*Telerik Authorship*/
private AssemblyDefinition Resolve(AssemblyNameReference name, string defaultPath, ReaderParameters parameters, TargetArchitecture architecture, SpecialTypeAssembly special, bool bubbleToUserIfFailed, bool addToFailedCache = true)
{
if (!string.IsNullOrEmpty(defaultPath))
{
this.AddSearchDirectory(defaultPath);
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (parameters == null)
{
parameters = new ReaderParameters(this);
}
/*Telerik Authorship*/
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(name.FullName, architecture, special);
AssemblyName assemblyName = new AssemblyName(name.Name, name.FullName, name.Version, name.PublicKey)
{
TargetArchitecture = architecture
};
AssemblyDefinition assembly = null;
/*Telerik Authorship*/
bool isResolved = DoWithReadLock(this.resolveLock, () =>
{
if (assemblyPathResolver.IsFailedAssembly(assemblyKey))
{
assembly = null;
return(true);
}
assembly = GetFromResolvedAssemblies(assemblyName, special);
return(assembly != null);
});
if (isResolved)
{
return(assembly);
}
/*Telerik Authorship*/
return(DoWithWriteLock(this.resolveLock, () =>
{
// Double checks to ensure that the entry is not added in the meantime.
if (assemblyPathResolver.IsFailedAssembly(assemblyKey))
{
return null;
}
assembly = GetFromResolvedAssemblies(assemblyName, special);
if (assembly != null)
{
return assembly;
}
/*Telerik Authorship*/
// This code has been added by Mono.Cecil 0.9.6. It has been commented, because retargetable references should be further
// researched and handled appropriately across the application. TP item N. 323383
//if (name.IsRetargetable)
//{
// // if the reference is retargetable, zero it
// name = new AssemblyNameReference(name.Name, new Version(0, 0, 0, 0))
// {
// PublicKeyToken = Empty<byte>.Array,
// };
//}
assembly = SearchDirectory(name, parameters, architecture, defaultPath) ?? TryGetTargetAssembly(name, parameters, architecture, assemblyKey);
if (assembly != null)
{
if (!filePathToAssemblyDefinitionCache.ContainsKey(assembly.MainModule.FilePath))
{
AddToResolvedAssemblies(assembly);
}
return assembly;
}
assembly = GetTargetAssembly(name, parameters, architecture);
if (assembly != null)
{
if (!filePathToAssemblyDefinitionCache.ContainsKey(assembly.MainModule.FilePath))
{
AddToResolvedAssemblies(assembly);
}
return assembly;
}
if (bubbleToUserIfFailed)
{
return UserSpecifiedAssembly(name, architecture, assemblyKey);
}
else if (addToFailedCache)
{
assemblyPathResolver.AddToUnresolvedCache(assemblyKey);
}
return null;
}));
}
