private Object ResolveAssemblyReference(AssemblyReferenceHandle handle)
{
AssemblyReference assemblyReference = _metadataReader.GetAssemblyReference(handle);
AssemblyName an = new AssemblyName();
an.Name = _metadataReader.GetString(assemblyReference.Name);
an.Version = assemblyReference.Version;
var publicKeyOrToken = _metadataReader.GetBlobBytes(assemblyReference.PublicKeyOrToken);
if ((assemblyReference.Flags & AssemblyFlags.PublicKey) != 0)
{
an.SetPublicKey(publicKeyOrToken);
}
else
{
an.SetPublicKeyToken(publicKeyOrToken);
}
an.CultureName = _metadataReader.GetString(assemblyReference.Culture);
an.ContentType = GetContentTypeFromAssemblyFlags(assemblyReference.Flags);
return(Context.ResolveAssembly(an));
}
/// <summary>
/// Tries to locate the assembly containing <see cref="object"/>.
/// </summary>
public bool TryGetSystemRuntimeAssemblyInformation(MetadataReader reader, out AssemblyReferenceInformation assemblyReference)
{
if (reader.TryGetCurrentAssemblyName(out var name) && SystemObjectAssemblies.Contains(name))
{
assemblyReference = reader.FormatAssemblyInfo();
return(true);
}
var microsoftAssemblies = reader.AssemblyReferences
.Select(handle =>
{
var assembly = reader.GetAssemblyReference(handle);
return(reader.FormatAssemblyInfo(assembly));
})
.Where(_assemblyFilter.IsFrameworkAssembly)
.Where(assembly => SystemObjectAssemblies.Contains(assembly.Name))
.OrderByDescending(assembly => assembly.Version);
var matchingAssembly = microsoftAssemblies.FirstOrDefault();
if (matchingAssembly != default(AssemblyReferenceInformation))
{
assemblyReference = matchingAssembly;
return(true);
}
assemblyReference = null;
return(false);
}
private static void GetReferenceFullNameAndAssembly(Handle definition, MetadataReader metadataReader, out string referenceFullName, out string referenceAssemblyName)
{
var typeReference = metadataReader.GetTypeReference((TypeReferenceHandle)definition);
var references = new Stack <TypeReference>();
references.Push(typeReference);
while (typeReference.ResolutionScope.Kind == HandleKind.TypeReference)
{
typeReference = metadataReader.GetTypeReference((TypeReferenceHandle)typeReference.ResolutionScope);
references.Push(typeReference);
}
var topReference = references.Pop();
var topReferenceNs = metadataReader.GetString(topReference.Namespace);
referenceFullName = (topReferenceNs.Length > 0 ? topReferenceNs + TypeSeparator : string.Empty) +
metadataReader.GetString(topReference.Name) +
(references.Count > 0
? InnerTypeSeparator +
string.Join(InnerTypeSeparator, references.Select(x => metadataReader.GetString(x.Name)))
: string.Empty);
Debug.Assert(typeReference.ResolutionScope.Kind == HandleKind.AssemblyReference,
"typeReference.ResolutionScope.Kind == HandleKind.AssemblyReference; actual = " +
typeReference.ResolutionScope.Kind);
var assemblyReference = metadataReader.GetAssemblyReference((AssemblyReferenceHandle)typeReference.ResolutionScope);
referenceAssemblyName = metadataReader.GetString(assemblyReference.Name);
}
public virtual string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind = 0)
{
TypeReference reference = reader.GetTypeReference(handle);
Handle scope = reference.ResolutionScope;
string name = reference.Namespace.IsNil
? reader.GetString(reference.Name)
: reader.GetString(reference.Namespace) + "." + reader.GetString(reference.Name);
switch (scope.Kind)
{
case HandleKind.ModuleReference:
return("[.module " + reader.GetString(reader.GetModuleReference((ModuleReferenceHandle)scope).Name) + "]" + name);
case HandleKind.AssemblyReference:
var assemblyReferenceHandle = (AssemblyReferenceHandle)scope;
var assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
return("[" + reader.GetString(assemblyReference.Name) + "]" + name);
case HandleKind.TypeReference:
return(GetTypeFromReference(reader, (TypeReferenceHandle)scope) + "/" + name);
default:
return(name);
}
}
internal static ManagedPlatform ComputeIsDotNetCore(MetadataReader metadataReader)
{
foreach (AssemblyReferenceHandle handle in metadataReader.AssemblyReferences)
{
AssemblyReference assemblyReference = metadataReader.GetAssemblyReference(handle);
StringHandle stringHandle = assemblyReference.Name;
string assemblyName = metadataReader.GetString(stringHandle);
switch (assemblyName)
{
case "mscorlib":
{
return(ManagedPlatform.DotNetFramework);
}
case "System.Runtime":
{
return(ManagedPlatform.DotNetCore);
}
case "netstandard":
{
return(ManagedPlatform.DotNetStandard);
}
default:
{
break;
}
}
}
throw new InvalidOperationException("Could not identify managed platform.");
}
private static bool TryFindAssemblyReference(EntityHandle handle, MetadataReader metadata, out AssemblyReference assemblyReference)
{
assemblyReference = default;
switch (handle.Kind)
{
case HandleKind.AssemblyReference:
{
assemblyReference = metadata.GetAssemblyReference((AssemblyReferenceHandle)handle);
return(true);
}
case HandleKind.TypeReference:
{
var typeReference = metadata.GetTypeReference((TypeReferenceHandle)handle);
return(TryFindAssemblyReference(typeReference.ResolutionScope, metadata, out assemblyReference));
}
case HandleKind.TypeSpecification:
{
// To do this properly, we need to call TypeSpecification.DecodeSignature, but use an
// ISignatureTypeProvider that allows us to get the assembly, rather than the type name.
// Something to do later.
return(false);
}
case HandleKind.MemberReference:
{
var memberReference = metadata.GetMemberReference((MemberReferenceHandle)handle);
return(TryFindAssemblyReference(memberReference.Parent, metadata, out assemblyReference));
}
default:
throw new NotImplementedException(handle.Kind.ToString());
}
}
internal static bool GetFileDependsOnNETStandard(string filePath)
{
using (var assemblyStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))
using (PEReader peReader = new PEReader(assemblyStream, PEStreamOptions.LeaveOpen))
{
if (peReader.HasMetadata)
{
MetadataReader reader = peReader.GetMetadataReader();
if (reader.IsAssembly)
{
foreach (var referenceHandle in reader.AssemblyReferences)
{
AssemblyReference reference = reader.GetAssemblyReference(referenceHandle);
if (reader.StringComparer.Equals(reference.Name, NetStandardAssemblyName))
{
return(true);
}
if (reader.StringComparer.Equals(reference.Name, SystemRuntimeAssemblyName) &&
reference.Version >= SystemRuntimeMinVersion)
{
return(true);
}
}
}
}
}
return(false);
}
public virtual string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code = SignatureTypeHandleCode.Unresolved)
{
TypeReference reference = reader.GetTypeReference(handle);
Handle scope = reference.ResolutionScope;
string name = reference.Namespace.IsNil
? reader.GetString(reference.Name)
: reader.GetString(reference.Namespace) + "." + reader.GetString(reference.Name);
switch (scope.Kind)
{
case HandleKind.ModuleReference:
return("[.module " + reader.GetString(reader.GetModuleReference((ModuleReferenceHandle)scope).Name) + "]" + name);
case HandleKind.AssemblyReference:
var assemblyReferenceHandle = (AssemblyReferenceHandle)scope;
var assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
return("[" + reader.GetString(assemblyReference.Name) + "]" + name);
case HandleKind.TypeReference:
return(GetTypeFromReference(reader, (TypeReferenceHandle)scope, code) + "/" + name);
default:
// rare cases: ModuleDefinition means search within defs of current module (used by WinMDs for projections)
// nil means search exported types of same module (haven't seen this in practice). For the test
// purposes here, it's sufficient to format both like defs.
Debug.Assert(scope == Handle.ModuleDefinition || scope.IsNil);
return(name);
}
}
/// <summary>
/// Try to locate a (reference) assembly using the list of explicit reference assemblies
/// and the list of reference paths passed to R2RDump.
/// </summary>
/// <param name="simpleName">Simple name of the assembly to look up</param>
/// <param name="parentFile">Name of assembly from which we're performing the lookup</param>
/// <returns></returns>
public MetadataReader FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile)
{
string simpleName = metadataReader.GetString(metadataReader.GetAssemblyReference(assemblyReferenceHandle).Name);
foreach (FileInfo refAsm in Reference ?? Enumerable.Empty <FileInfo>())
{
if (Path.GetFileNameWithoutExtension(refAsm.FullName).Equals(simpleName, StringComparison.OrdinalIgnoreCase))
{
return(Open(refAsm.FullName));
}
}
IEnumerable <string> allRefPaths = new string[] { Path.GetDirectoryName(parentFile) }
.Concat((ReferencePath ?? Enumerable.Empty <DirectoryInfo>()).Select(path => path.FullName));
foreach (string refPath in allRefPaths)
{
foreach (string extension in ProbeExtensions)
{
string probeFile = Path.Combine(refPath, simpleName + extension);
if (File.Exists(probeFile))
{
return(Open(probeFile));
}
}
}
return(null);
}
public MrType GetTypeFromReference(MetadataReader reader, TypeReferenceHandle referenceHandle)
{
var typeReference = reader.GetTypeReference(referenceHandle);
var scopeEntityHandle = typeReference.ResolutionScope;
string name = typeReference.Namespace.IsNil
? reader.GetString(typeReference.Name)
: reader.GetString(typeReference.Namespace) + "." + reader.GetString(typeReference.Name);
switch (scopeEntityHandle.Kind)
{
case HandleKind.AssemblyReference:
{
var assemblyReferenceHandle = (AssemblyReferenceHandle)scopeEntityHandle;
var assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle);
return(GetTypeFromAssembly(name, reader.GetString(assemblyReference.Name)));
}
case HandleKind.ModuleDefinition:
{
return(GetType(name));
}
case HandleKind.TypeReference:
{
// Todo: is there a way to get the assembly being referenced? Or is it always the same one?
TryFindMrType(name, reader, out var mrType);
return(mrType);
}
default:
throw new NotSupportedException();
}
}
private void WriteAssemblyRef()
{
AddHeader(
"Name",
"Version",
"Culture",
"PublicKeyOrToken",
"Flags"
);
foreach (var handle in reader.AssemblyReferences)
{
var entry = reader.GetAssemblyReference(handle);
AddRow(
Literal(entry.Name),
entry.Version.Major + "." + entry.Version.Minor + "." + entry.Version.Revision + "." + entry.Version.Build,
Literal(entry.Culture),
Literal(entry.PublicKeyOrToken),
EnumValue <int>(entry.Flags)
);
}
WriteRows("AssemblyRef (0x23):");
}
private Object ResolveAssemblyReference(AssemblyReferenceHandle handle)
{
AssemblyReference assemblyReference = _metadataReader.GetAssemblyReference(handle);
AssemblyName an = new AssemblyName();
an.Name = _metadataReader.GetString(assemblyReference.Name);
an.Version = assemblyReference.Version;
var publicKeyOrToken = _metadataReader.GetBlobBytes(assemblyReference.PublicKeyOrToken);
if ((assemblyReference.Flags & AssemblyFlags.PublicKey) != 0)
{
an.SetPublicKey(publicKeyOrToken);
}
else
{
an.SetPublicKeyToken(publicKeyOrToken);
}
an.CultureName = _metadataReader.GetString(assemblyReference.Culture);
an.ContentType = GetContentTypeFromAssemblyFlags(assemblyReference.Flags);
var assembly = _moduleResolver.ResolveAssembly(an, throwIfNotFound: false);
if (assembly == null)
{
return(ResolutionFailure.GetAssemblyResolutionFailure(an.Name));
}
else
{
return(assembly);
}
}
/// <summary>
/// Open a given reference assembly (relative to this ECMA metadata file).
/// </summary>
/// <param name="refAsmIndex">Reference assembly index</param>
/// <returns>EcmaMetadataReader instance representing the reference assembly</returns>
public EcmaMetadataReader OpenReferenceAssembly(int refAsmIndex)
{
if (refAsmIndex == 0)
{
return(this);
}
int assemblyRefCount = MetadataReader.GetTableRowCount(TableIndex.AssemblyRef);
string name;
if (refAsmIndex <= assemblyRefCount)
{
AssemblyReference asmRef = MetadataReader.GetAssemblyReference(MetadataTokens.AssemblyReferenceHandle(refAsmIndex));
name = MetadataReader.GetString(asmRef.Name);
}
else
{
name = ManifestReferenceAssemblies[refAsmIndex - assemblyRefCount - 2];
}
EcmaMetadataReader ecmaReader;
if (!_assemblyCache.TryGetValue(name, out ecmaReader))
{
string assemblyPath = _assemblyResolver.FindAssembly(name, Filename);
if (assemblyPath == null)
{
throw new Exception($"Missing reference assembly: {name}");
}
ecmaReader = new EcmaMetadataReader(_assemblyResolver, assemblyPath, ManifestReferenceAssemblies);
_assemblyCache.Add(name, ecmaReader);
}
return(ecmaReader);
}
// https://github.com/Microsoft/msbuild/issues/4002
// https://github.com/dotnet/corefx/issues/34008
//
// We do not use AssemblyReference.GetAssemblyName() here because its behavior
// is different from other code paths with respect to neutral culture. We will
// get unspecified culture instead of explicitly neutral culture. This in turn
// leads string comparisons of assembly-name-modulo-version in RAR to false
// negatives that break its conflict resolution and binding redirect generation.
private static AssemblyName GetAssemblyName(MetadataReader metadataReader, AssemblyReferenceHandle handle)
{
var entry = metadataReader.GetAssemblyReference(handle);
var assemblyName = new AssemblyName
{
Name = metadataReader.GetString(entry.Name),
Version = entry.Version,
CultureName = metadataReader.GetString(entry.Culture)
};
var publicKeyOrToken = metadataReader.GetBlobBytes(entry.PublicKeyOrToken);
if (publicKeyOrToken != null)
{
if (publicKeyOrToken.Length <= 8)
{
assemblyName.SetPublicKeyToken(publicKeyOrToken);
}
else
{
assemblyName.SetPublicKey(publicKeyOrToken);
}
}
assemblyName.Flags = (AssemblyNameFlags)(int)entry.Flags;
return(assemblyName);
}
private static bool AssemblyHasWindowsRuntimeReference(string sourcePath)
{
using (var assemblyStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))
{
try
{
using (PEReader peReader = new PEReader(assemblyStream, PEStreamOptions.LeaveOpen))
{
if (peReader.HasMetadata)
{
MetadataReader reader = peReader.GetMetadataReader();
if (reader.IsAssembly)
{
foreach (var assemblyReferenceHandle in reader.AssemblyReferences)
{
if ((reader.GetAssemblyReference(assemblyReferenceHandle).Flags & System.Reflection.AssemblyFlags.WindowsRuntime) == System.Reflection.AssemblyFlags.WindowsRuntime)
{
return(true);
}
}
}
}
}
}
catch (BadImageFormatException)
{
// not a PE
return(false);
}
return(false);
}
}
/// <exception cref="BadImageFormatException">An exception from metadata reader.</exception>
internal static ImmutableArray <AssemblyIdentity> GetReferencedAssembliesOrThrow(this MetadataReader reader)
{
var result = ArrayBuilder <AssemblyIdentity> .GetInstance(reader.AssemblyReferences.Count);
try
{
foreach (var assemblyRef in reader.AssemblyReferences)
{
AssemblyReference reference = reader.GetAssemblyReference(assemblyRef);
result.Add(reader.CreateAssemblyIdentityOrThrow(
reference.Version,
reference.Flags,
reference.PublicKeyOrToken,
reference.Name,
reference.Culture,
isReference: true));
}
return(result.ToImmutable());
}
finally
{
result.Free();
}
}
public static AssemblyReference GetAssemblyReferenceForExportedType(MetadataReader metaReader, ExportedType exportedType)
{
if (exportedType.Implementation.Kind == HandleKind.AssemblyReference)
{
return(metaReader.GetAssemblyReference((AssemblyReferenceHandle)exportedType.Implementation));
}
else if (exportedType.Implementation.Kind == HandleKind.ExportedType)
{
// this means we have an exported nested type.
/*
* .class extern forwarder System.TimeZoneInfo
* {
* .assembly extern mscorlib
* }
* .class extern AdjustmentRule
* {
* .class extern System.TimeZoneInfo
* }
*/
return(GetAssemblyReferenceForExportedType(metaReader, metaReader.GetExportedType(((ExportedTypeHandle)exportedType.Implementation))));
}
return(default(AssemblyReference));
}
public AssemblyRefEntry(PEFile module, AssemblyReferenceHandle handle)
{
this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
this.module = module;
this.metadata = module.Metadata;
this.handle = handle;
this.assemblyRef = metadata.GetAssemblyReference(handle);
}
public static IEnumerable <string> GetReferenceAssemblyFullNames(this MetadataReader metadataReader)
{
foreach (var assemblyReferenceHandle in metadataReader.AssemblyReferences)
{
var assemblyReference = metadataReader.GetAssemblyReference(assemblyReferenceHandle);
var fullAssemblyName = metadataReader.GetFullAssemblyName(assemblyReference);
yield return(fullAssemblyName);
}
}
private static string GetAssemblyReferenceName(
MetadataReader reader,
AssemblyReferenceHandle handle
)
{
var reference = reader.GetAssemblyReference(handle);
return(reader.GetString(reference.Name));
}
private static void BuildFullName(EntityHandle handle, MetadataReader metadata, StringBuilder sb, out string assembly)
{
void BuildName(StringHandle stringHandle)
{
if (!stringHandle.IsNil)
{
if (sb.Length != 0)
{
sb.Append('.');
}
var value = metadata.GetString(stringHandle);
sb.Append(value);
}
}
switch (handle.Kind)
{
case HandleKind.MemberReference:
{
var memberReference = metadata.GetMemberReference((MemberReferenceHandle)handle);
BuildFullName(memberReference.Parent, metadata, sb, out assembly);
BuildName(memberReference.Name);
}
break;
case HandleKind.TypeReference:
{
var typeReference = metadata.GetTypeReference((TypeReferenceHandle)handle);
BuildFullName(typeReference.ResolutionScope, metadata, sb, out assembly);
BuildName(typeReference.Namespace);
BuildName(typeReference.Name);
}
break;
case HandleKind.AssemblyReference:
{
var assemblyReference = metadata.GetAssemblyReference((AssemblyReferenceHandle)handle);
assembly = metadata.GetString(assemblyReference.Name);
}
break;
case HandleKind.TypeDefinition:
{
var typeDefinition = metadata.GetTypeDefinition((TypeDefinitionHandle)handle);
BuildName(typeDefinition.Namespace);
BuildName(typeDefinition.Name);
// I think type definitions are always defined in the containing assembly.
// When it appears it should belong elsewhere, I think it's an embedded (COM?) type.
assembly = GetCurrentAssemblyName(metadata);
}
break;
default:
throw new NotImplementedException(handle.Kind.ToString());
}
}
public static IEnumerable <string> GetReferenceAssemblyPartialNames(this MetadataReader metadataReader)
{
foreach (var assemblyReferenceHandle in metadataReader.AssemblyReferences)
{
var assemblyReference = metadataReader.GetAssemblyReference(assemblyReferenceHandle);
var partialName = metadataReader.GetString(assemblyReference.Name);
yield return(partialName);
}
}
public override bool Execute()
{
if (Assemblies == null || Assemblies.Length == 0)
{
return(true);
}
List <ITaskItem> references = new List <ITaskItem>();
List <ITaskItem> nativeLibs = new List <ITaskItem>();
foreach (var assemblyItem in Assemblies)
{
try
{
if (!File.Exists(assemblyItem.ItemSpec))
{
Log.LogError($"File {assemblyItem.ItemSpec} does not exist, ensure you have built libraries before building the package.");
continue;
}
using (PEReader peReader = new PEReader(new FileStream(assemblyItem.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read)))
{
MetadataReader reader = peReader.GetMetadataReader();
foreach (var handle in reader.AssemblyReferences)
{
AssemblyReference reference = reader.GetAssemblyReference(handle);
TaskItem referenceItem = new TaskItem(reader.GetString(reference.Name));
assemblyItem.CopyMetadataTo(referenceItem);
referenceItem.SetMetadata("Version", reference.Version.ToString());
referenceItem.SetMetadata("AssemblyVersion", reference.Version.ToString());
references.Add(referenceItem);
}
for (int i = 1, count = reader.GetTableRowCount(TableIndex.ModuleRef); i <= count; i++)
{
var moduleRef = reader.GetModuleReference(MetadataTokens.ModuleReferenceHandle(i));
var moduleName = reader.GetString(moduleRef.Name);
TaskItem nativeLib = new TaskItem(moduleName);
assemblyItem.CopyMetadataTo(nativeLib);
nativeLibs.Add(nativeLib);
}
}
}
catch (InvalidOperationException)
{
// Ignore invalid assemblies
}
}
ReferencedAssemblies = references.ToArray();
ReferencedNativeLibraries = nativeLibs.ToArray();
return(true);
}
public static string Dump(this MetadataReader reader, EntityHandle handle)
{
switch (handle.Kind)
{
case HandleKind.AssemblyReference:
return("AssemblyRef:" + reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name));
default:
return(handle.Kind.ToString());
}
}
private static string DumpRec(this MetadataReader reader, EntityHandle handle)
{
switch (handle.Kind)
{
case HandleKind.AssemblyReference:
return(reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name));
case HandleKind.TypeDefinition:
{
TypeDefinition type = reader.GetTypeDefinition((TypeDefinitionHandle)handle);
return(getQualifiedName(type.Namespace, type.Name));
}
case HandleKind.MethodDefinition:
{
MethodDefinition method = reader.GetMethodDefinition((MethodDefinitionHandle)handle);
var blob = reader.GetBlobReader(method.Signature);
var decoder = new SignatureDecoder <string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
var parameters = signature.ParameterTypes.Join(", ");
return($"{signature.ReturnType} {DumpRec(reader, method.GetDeclaringType())}.{reader.GetString(method.Name)}({parameters})");
}
case HandleKind.MemberReference:
{
MemberReference member = reader.GetMemberReference((MemberReferenceHandle)handle);
var blob = reader.GetBlobReader(member.Signature);
var decoder = new SignatureDecoder <string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
var parameters = signature.ParameterTypes.Join(", ");
return($"{signature.ReturnType} {DumpRec(reader, member.Parent)}.{reader.GetString(member.Name)}({parameters})");
}
case HandleKind.TypeReference:
{
TypeReference type = reader.GetTypeReference((TypeReferenceHandle)handle);
return(getQualifiedName(type.Namespace, type.Name));
}
default:
return(null);
}
string getQualifiedName(StringHandle leftHandle, StringHandle rightHandle)
{
string name = reader.GetString(rightHandle);
if (!leftHandle.IsNil)
{
name = reader.GetString(leftHandle) + "." + name;
}
return(name);
}
}
public static TypeIdentifier GetFrom(MetadataReader reader, TypeReference reference)
{
AssemblyName assemblyName = null;
if (reference.ResolutionScope.Kind == HandleKind.AssemblyReference)
{
var asmRef = reader.GetAssemblyReference((AssemblyReferenceHandle)reference.ResolutionScope);
assemblyName = reader.ParseAssemblyName(asmRef);
}
return new TypeIdentifier(reader.GetString(reference.Name), reader.GetString(reference.Namespace), assemblyName);
}
public ScannedAssembly(AssemblyReferenceHandle handle, MetadataReader reader)
{
var reference = reader.GetAssemblyReference(handle);
Name = reader.GetString(reference.Name);
Culture = reader.GetString(reference.Culture);
PublicKey = reader.GetBlobBytes(reference.PublicKeyOrToken).ToList();
Token = reader.GetToken(handle);
Version = reference.Version;
Flags = reference.Flags;
ResolutionStatus = ResolutionStatus.UnResolved;
}
public LoadedAssembly(AssemblyData assemblyData)
{
IsReferenecOnly = assemblyData.IsReferenecOnly;
_fileStream = new FileStream(assemblyData.Location, FileMode.Open, FileAccess.Read);
_peReader = new PEReader(_fileStream, PEStreamOptions.LeaveOpen);
MetadataReader = _peReader.GetMetadataReader();
var assemblyDefinition = MetadataReader.GetAssemblyDefinition();
Assembly = new AssemblyDefinition(MetadataReader.GetString(assemblyDefinition.Name),
assemblyDefinition.Version);
References = MetadataReader.AssemblyReferences.Select(t => MetadataReader.GetAssemblyReference(t)).ToImmutableArray();
}
private static Reference[] GetAssemblyReferences(MetadataReader reader)
{
var references = new List <Reference>();
foreach (var handle in reader.AssemblyReferences)
{
var reference = reader.GetAssemblyReference(handle);
references.Add(new Reference(reader.GetString(reference.Name), reference.Version));
}
return(references.ToArray());
}
private static bool ReferencesWinMD(MetadataReader mdReader)
{
foreach (var assemblyRefHandle in mdReader.AssemblyReferences)
{
AssemblyReference assemblyRef = mdReader.GetAssemblyReference(assemblyRefHandle);
if ((assemblyRef.Flags & AssemblyFlags.WindowsRuntime) == AssemblyFlags.WindowsRuntime)
{
return(true);
}
}
return(false);
}
