private void WriteAssembly(ref int pos, IAssemblySignature assembly)
{
_blob.Write(ref pos, (byte)SignatureType.Assembly);
WriteString(ref pos, assembly.Name);
WriteString(ref pos, assembly.Culture);
// Version
var version = assembly.Version;
if (version != null)
{
_blob.Write(ref pos, true);
_blob.Write(ref pos, (ushort)version.Major);
_blob.Write(ref pos, (ushort)version.Minor);
_blob.Write(ref pos, (ushort)version.Build);
_blob.Write(ref pos, (ushort)version.Revision);
}
else
{
_blob.Write(ref pos, false);
}
// PublicKeyToken
var publicKeyToken = assembly.PublicKeyToken;
if (publicKeyToken != null)
{
_blob.Write7BitEncodedInt(ref pos, publicKeyToken.Length);
_blob.Write(ref pos, publicKeyToken);
}
else
{
_blob.Write(ref pos, (byte)0);
}
}
public static string ToReflectionString(this IAssemblySignature assemblySig, SignaturePrintingFlags flags = SignaturePrintingFlags.None)
{
var printer = new ReflectionSignaturePrinter(flags);
printer.PrintAssembly(assemblySig);
return(printer.ToString());
}
public int GetHashCode(IAssemblySignature obj)
{
int hashCode = 0x4000;
if (obj.Name != null)
{
hashCode ^= obj.Name.GetHashCode();
}
return(hashCode);
}
protected bool ResolveGAC(IAssemblySignature assemblySig, out string foundPath)
{
string assemblyName;
if (assemblySig.IsStrongNameSigned)
{
assemblyName = assemblySig.ToString();
}
else
{
assemblyName = assemblySig.Name;
}
return(ResolveGAC(assemblyName, out foundPath));
}
public IAssembly Resolve(IAssemblySignature assemblySig, IModule context, bool throwOnFailure = false)
{
var assembly = ResolveAssembly(assemblySig, context);
if (assembly == null)
{
if (throwOnFailure)
{
throw new ResolveReferenceException(string.Format(SR.AssemblyResolveError, assemblySig.ToReflectionString()));
}
return(null);
}
return(assembly);
}
protected override IAssembly ResolveAssembly(IAssemblySignature assemblySig, IModule context)
{
var key = new ResolveCacheKey()
{
Signature = assemblySig,
Context = context,
};
ICodeNode node;
if (!_resolveCache.TryGetValue(key, out node))
{
node = base.ResolveAssembly(assemblySig, context);
_resolveCache.Add(key, node);
}
return((IAssembly)node);
}
protected virtual IAssembly ResolveAssembly(IAssemblySignature assemblySig, string codeBase)
{
var assembly = GetAssembly(assemblySig);
if (assembly != null)
{
return(assembly);
}
string foundPath;
if (!ResolveAssemblyPath(assemblySig, codeBase, out foundPath))
{
return(null);
}
return(LoadAssembly(foundPath));
}
private IAssembly GetAssembly(IAssemblySignature assemblySig, bool throwIfMissing = false)
{
var comparer = SignatureComparer.Default;
foreach (var assembly in _assemblyByLocation.Values)
{
if (comparer.Equals(assembly, assemblySig))
{
return(assembly);
}
}
if (throwIfMissing)
{
throw new ResolveReferenceException(string.Format(SR.AssemblyNotFound, assemblySig.ToString()));
}
return(null);
}
private bool EqualsTypeOwner(IAssemblySignature x, IModuleSignature y, IModule yModule)
{
if (!yModule.IsPrimeModule)
{
return(false);
}
if (y.Name != yModule.Name)
{
return(false);
}
if (!EqualsAssembly(x, (IAssemblySignature)yModule.Assembly))
{
return(false);
}
return(true);
}
protected bool ResolveAssemblyPath(IAssemblySignature assemblySig, string codeBase, out string foundPath)
{
bool resolveFromGAC = (!_resolveIgnoreGAC && assemblySig.IsStrongNameSigned);
if (resolveFromGAC)
{
if (ResolveGAC(assemblySig, out foundPath))
{
return(true);
}
}
if (!_resolveIgnoreCodeBase && !string.IsNullOrEmpty(codeBase))
{
if (ResolveAssemblyFromPath(Path.GetDirectoryName(codeBase), assemblySig.Name, out foundPath))
{
return(true);
}
foreach (string searchPath in _resolveSearchFolders)
{
if (ResolveAssemblyFromPath(searchPath, assemblySig.Name, out foundPath))
{
return(true);
}
}
}
if (resolveFromGAC)
{
if (ResolveGAC(assemblySig.Name, out foundPath))
{
return(true);
}
}
foundPath = null;
return(false);
}
public bool Equals(IAssemblySignature x, IAssemblySignature y)
{
if (x == y)
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
if (x.Name != y.Name)
{
return(false);
}
if ((_flags & SignatureComparisonFlags.IgnoreAssemblyStrongName) != SignatureComparisonFlags.IgnoreAssemblyStrongName)
{
if (x.Culture != y.Culture)
{
return(false);
}
if (!CompareUtils.Equals(x.Version, y.Version, true))
{
return(false);
}
if (!CompareUtils.Equals(x.PublicKeyToken, y.PublicKeyToken))
{
return(false);
}
}
return(true);
}
private bool EqualsAssembly(IAssemblySignature x, IAssemblySignature y)
{
if (x == y)
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
if (x.Name != y.Name)
{
return(false);
}
if (!CompareUtils.Equals(x.PublicKeyToken, y.PublicKeyToken))
{
return(false);
}
return(true);
}
public static DotNetFramework GetByMscorlib(IAssemblySignature mscorlib)
{
return(Get(GetFrameworkTypeByPublicKeyToken(mscorlib.PublicKeyToken), mscorlib.Version));
}
protected virtual IAssembly ResolveAssembly(IAssemblySignature assemblySig, IModule context)
{
return(ResolveAssembly(assemblySig, context.Location));
}
public static IAssembly Resolve(this IAssemblySignature assemblySig, IModule context, bool throwOnFailure = false)
{
return(context.AssemblyManager.Resolve(assemblySig, context, throwOnFailure));
}
internal static void PrintAssembly(StringBuilder builder, IAssemblySignature assemblySig, SignaturePrintingFlags flags)
{
builder.Append(assemblySig.Name);
if ((flags & SignaturePrintingFlags.IgnoreAssemblyStrongName) != SignaturePrintingFlags.IgnoreAssemblyStrongName)
{
bool ignoreDefaultValues = (flags & SignaturePrintingFlags.IgnoreAssemblyStrongNameDefaultValues) == SignaturePrintingFlags.IgnoreAssemblyStrongNameDefaultValues;
// Version
if (assemblySig.Version != null)
{
builder.AppendFormat(", Version={0}", assemblySig.Version.ToString());
}
else if (!ignoreDefaultValues)
{
builder.Append(", Version=0.0.0.0");
}
// Culture
if (!string.IsNullOrEmpty(assemblySig.Culture))
{
builder.AppendFormat(", Culture={0}", assemblySig.Culture);
}
else if (!ignoreDefaultValues)
{
builder.Append(", Culture=neutral");
}
// PublicKeyToken
if (assemblySig.PublicKeyToken != null && assemblySig.PublicKeyToken.Length > 0)
{
builder.AppendFormat(", PublicKeyToken={0}", ConvertUtils.ToHexString(assemblySig.PublicKeyToken).ToLower());
}
else if (!ignoreDefaultValues)
{
builder.Append(", PublicKeyToken=null");
}
// ProcessorArchitecture
string procArchString;
switch (assemblySig.ProcessorArchitecture)
{
case ProcessorArchitecture.MSIL:
procArchString = "msil";
break;
case ProcessorArchitecture.X86:
procArchString = "x86";
break;
case ProcessorArchitecture.Amd64:
procArchString = "amd64";
break;
case ProcessorArchitecture.IA64:
procArchString = "ia64";
break;
default:
procArchString = null;
break;
}
if (procArchString != null)
{
builder.AppendFormat(", ProcessorArchitecture={0}", procArchString);
}
}
}
internal void PrintAssembly(IAssemblySignature assemblySig)
{
SignaturePrinter.PrintAssembly(_builder, assemblySig, _flags);
}
public void PrintAssembly(IAssemblySignature assemblySig)
{
PrintAssembly(_builder, assemblySig, _flags);
}
