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); }