public string FindAssemblyFile(string fullName)
{
return(FindAssemblyFile(AssemblyNameReference.Parse(fullName)));
}
protected override void OnExecute(object sender, EventArgs e)
{
var explorer = owner.DTE.ToolWindows.SolutionExplorer;
var item = ((object[])explorer.SelectedItems).FirstOrDefault() as UIHierarchyItem;
if (item == null)
{
return;
}
if (item.Object is Reference reference)
{
var project = reference.ContainingProject;
var roslynProject = owner.Workspace.CurrentSolution.Projects.FirstOrDefault(p => p.FilePath == project.FileName);
var references = GetReferences(roslynProject);
if (references.TryGetValue(reference.Name, out var path))
{
OpenAssembliesInILSpy(new[] { path });
}
else
{
owner.ShowMessage("Could not find reference '{0}', please ensure the project and all references were built correctly!", reference.Name);
}
}
else
{
dynamic referenceObject = item.Object;
var values = GetProperties(referenceObject.Properties, "Type", "FusionName", "ResolvedPath");
if (values[0] == "Package")
{
values = GetProperties(referenceObject.Properties, "Name", "Version", "Path");
if (values[0] != null && values[1] != null && values[2] != null)
{
OpenAssembliesInILSpy(new[] { $"{values[2]}\\{values[0]}.{values[1]}.nupkg" });
return;
}
}
else if (values[2] != null)
{
OpenAssembliesInILSpy(new[] { $"{values[2]}" });
return;
}
else if (!string.IsNullOrWhiteSpace(values[1]))
{
OpenAssembliesInILSpy(new string[] { GacInterop.FindAssemblyInNetGac(AssemblyNameReference.Parse(values[1])) });
return;
}
owner.ShowMessage("Could not find reference '{0}', please ensure the project and all references were built correctly!", referenceObject.Name);
}
}
public void NestedTypeForwarder()
{
var resolver = new CustomResolver();
var parameters = new ReaderParameters {
AssemblyResolver = resolver
};
var types = ModuleDefinition.ReadModule(
CompilationService.CompileResource(GetCSharpResourcePath("CustomAttributes.cs", typeof(ResolveTests).Assembly)),
parameters);
resolver.Register(types.Assembly);
var current_module = GetCurrentModule(parameters);
var reference = new TypeReference("", "DebuggingModes", current_module, null, true);
reference.DeclaringType = new TypeReference("System.Diagnostics", "DebuggableAttribute", current_module, AssemblyNameReference.Parse(types.Assembly.FullName), false);
var definition = reference.Resolve();
Assert.IsNotNull(definition);
Assert.AreEqual("System.Diagnostics.DebuggableAttribute/DebuggingModes", definition.FullName);
Assert.AreEqual("mscorlib", definition.Module.Assembly.Name.Name);
}
public void RunRegistrar()
{
// The static registrar.
if (Registrar != RegistrarMode.Static)
{
throw new ProductException(67, Errors.MT0067, Registrar); // this is only called during our own build
}
if (RootAssemblies.Count < 1)
{
throw ErrorHelper.CreateError(130, Errors.MX0130);
}
var registrar_m = RegistrarOutputLibrary;
var RootAssembly = RootAssemblies [0];
var resolvedAssemblies = new Dictionary <string, AssemblyDefinition> ();
var resolver = new PlatformResolver()
{
RootDirectory = Path.GetDirectoryName(RootAssembly),
#if MMP
CommandLineAssemblies = RootAssemblies,
#endif
};
if (Platform == ApplePlatform.iOS)
{
if (Is32Build)
{
resolver.ArchDirectory = Driver.GetArch32Directory(this);
}
else
{
resolver.ArchDirectory = Driver.GetArch64Directory(this);
}
}
var ps = new ReaderParameters();
ps.AssemblyResolver = resolver;
foreach (var reference in References)
{
var r = resolver.Load(reference);
if (r == null)
{
throw ErrorHelper.CreateError(2002, Errors.MT2002, reference);
}
}
var productAssembly = Driver.GetProductAssembly(this);
bool foundProductAssembly = false;
foreach (var asm in RootAssemblies)
{
var rootName = Path.GetFileNameWithoutExtension(asm);
if (rootName == productAssembly)
{
foundProductAssembly = true;
}
try {
AssemblyDefinition lastAssembly = ps.AssemblyResolver.Resolve(AssemblyNameReference.Parse(rootName), new ReaderParameters());
if (lastAssembly == null)
{
ErrorHelper.CreateWarning(7, Errors.MX0007, rootName);
continue;
}
if (resolvedAssemblies.TryGetValue(rootName, out var previousAssembly))
{
if (lastAssembly.MainModule.RuntimeVersion != previousAssembly.MainModule.RuntimeVersion)
{
Driver.Log(2, "Attemping to load an assembly another time {0} (previous {1})", lastAssembly.FullName, previousAssembly.FullName);
}
continue;
}
resolvedAssemblies.Add(rootName, lastAssembly);
Driver.Log(3, "Loaded {0}", lastAssembly.MainModule.FileName);
} catch (Exception ex) {
ErrorHelper.Warning(9, ex, Errors.MX0009, $"{rootName}: {ex.Message}");
continue;
}
}
if (!foundProductAssembly)
{
throw ErrorHelper.CreateError(131, Errors.MX0131, productAssembly, string.Join("', '", RootAssemblies.ToArray()));
}
#if MONOTOUCH
if (SelectAbis(Abis, Abi.SimulatorArchMask).Count > 0)
{
BuildTarget = BuildTarget.Simulator;
}
else if (SelectAbis(Abis, Abi.DeviceArchMask).Count > 0)
{
BuildTarget = BuildTarget.Device;
}
else
{
throw ErrorHelper.CreateError(99, Errors.MX0099, "No valid ABI");
}
#endif
var registrar = new Registrar.StaticRegistrar(this);
if (RootAssemblies.Count == 1)
{
registrar.GenerateSingleAssembly(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m, Path.GetFileNameWithoutExtension(RootAssembly));
}
else
{
registrar.Generate(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m);
}
}
public BamlDecompilerTypeSystem(PEFile mainModule, IAssemblyResolver assemblyResolver)
{
if (mainModule == null)
{
throw new ArgumentNullException(nameof(mainModule));
}
if (assemblyResolver == null)
{
throw new ArgumentNullException(nameof(assemblyResolver));
}
// Load referenced assemblies and type-forwarder references.
// This is necessary to make .NET Core/PCL binaries work better.
var referencedAssemblies = new List <PEFile>();
var assemblyReferenceQueue = new Queue <(bool IsAssembly, PEFile MainModule, object Reference)>();
var mainMetadata = mainModule.Metadata;
foreach (var h in mainMetadata.GetModuleReferences())
{
var moduleRef = mainMetadata.GetModuleReference(h);
var moduleName = mainMetadata.GetString(moduleRef.Name);
foreach (var fileHandle in mainMetadata.AssemblyFiles)
{
var file = mainMetadata.GetAssemblyFile(fileHandle);
if (mainMetadata.StringComparer.Equals(file.Name, moduleName) && file.ContainsMetadata)
{
assemblyReferenceQueue.Enqueue((false, mainModule, moduleName));
break;
}
}
}
foreach (var refs in mainModule.AssemblyReferences)
{
assemblyReferenceQueue.Enqueue((true, mainModule, refs));
}
foreach (var bamlReference in defaultBamlReferences)
{
assemblyReferenceQueue.Enqueue((true, mainModule, AssemblyNameReference.Parse(bamlReference)));
}
var comparer = KeyComparer.Create(((bool IsAssembly, PEFile MainModule, object Reference)reference) =>
reference.IsAssembly ? "A:" + ((IAssemblyReference)reference.Reference).FullName :
"M:" + reference.Reference);
var processedAssemblyReferences = new HashSet <(bool IsAssembly, PEFile Parent, object Reference)>(comparer);
while (assemblyReferenceQueue.Count > 0)
{
var asmRef = assemblyReferenceQueue.Dequeue();
if (!processedAssemblyReferences.Add(asmRef))
{
continue;
}
PEFile asm;
if (asmRef.IsAssembly)
{
asm = assemblyResolver.Resolve((IAssemblyReference)asmRef.Reference);
}
else
{
asm = assemblyResolver.ResolveModule(asmRef.MainModule, (string)asmRef.Reference);
}
if (asm != null)
{
referencedAssemblies.Add(asm);
var metadata = asm.Metadata;
foreach (var h in metadata.ExportedTypes)
{
var exportedType = metadata.GetExportedType(h);
switch (exportedType.Implementation.Kind)
{
case HandleKind.AssemblyReference:
assemblyReferenceQueue.Enqueue((true, asm, new ICSharpCode.Decompiler.Metadata.AssemblyReference(asm, (AssemblyReferenceHandle)exportedType.Implementation)));
break;
case HandleKind.AssemblyFile:
var file = metadata.GetAssemblyFile((AssemblyFileHandle)exportedType.Implementation);
assemblyReferenceQueue.Enqueue((false, asm, metadata.GetString(file.Name)));
break;
}
}
}
}
var mainModuleWithOptions = mainModule.WithOptions(TypeSystemOptions.Default);
var referencedAssembliesWithOptions = referencedAssemblies.Select(file => file.WithOptions(TypeSystemOptions.Default));
// Primitive types are necessary to avoid assertions in ILReader.
// Fallback to MinimalCorlib to provide the primitive types.
if (!HasType(KnownTypeCode.Void) || !HasType(KnownTypeCode.Int32))
{
Init(mainModule.WithOptions(TypeSystemOptions.Default), referencedAssembliesWithOptions.Concat(new[] { MinimalCorlib.Instance }));
}
else
{
Init(mainModuleWithOptions, referencedAssembliesWithOptions);
}
this.MainModule = (MetadataModule)base.MainModule;
bool HasType(KnownTypeCode code)
{
TopLevelTypeName name = KnownTypeReference.Get(code).TypeName;
if (!mainModule.GetTypeDefinition(name).IsNil)
{
return(true);
}
foreach (var file in referencedAssemblies)
{
if (!file.GetTypeDefinition(name).IsNil)
{
return(true);
}
}
return(false);
}
}
CustomAttrib.FixedArg ReadFixedArg(byte [] data, BinaryReader br,
TypeReference param, ref bool read, bool resolve)
{
CustomAttrib.FixedArg fa = new CustomAttrib.FixedArg();
if (param is ArrayType)
{
param = ((ArrayType)param).ElementType;
fa.SzArray = true;
fa.NumElem = br.ReadUInt32();
if (fa.NumElem == 0 || fa.NumElem == 0xffffffff)
{
fa.Elems = new CustomAttrib.Elem [0];
fa.NumElem = 0;
return(fa);
}
fa.Elems = new CustomAttrib.Elem [fa.NumElem];
for (int i = 0; i < fa.NumElem; i++)
{
fa.Elems [i] = ReadElem(data, br, param, ref read, resolve);
}
}
else
{
fa.Elems = new CustomAttrib.Elem [] { ReadElem(data, br, param, ref read, resolve) }
};
return(fa);
}
TypeReference CreateEnumTypeReference(string enumName)
{
string asmName = null;
int asmStart = enumName.IndexOf(',');
if (asmStart != -1)
{
asmName = enumName.Substring(asmStart + 1);
enumName = enumName.Substring(0, asmStart);
}
// Inner class style is reflection style.
enumName = enumName.Replace('+', '/');
AssemblyNameReference asm;
if (asmName == null)
{
// If no assembly is given then the ECMA standard says the
// assembly is either the current one or mscorlib.
if (m_reflectReader.Module.Types.Contains(enumName))
{
return(m_reflectReader.Module.Types [enumName]);
}
asm = m_reflectReader.Corlib;
}
else
{
asm = AssemblyNameReference.Parse(asmName);
}
string [] outers = enumName.Split('/');
string outerfullname = outers [0];
string ns = null;
int nsIndex = outerfullname.LastIndexOf('.');
if (nsIndex != -1)
{
ns = outerfullname.Substring(0, nsIndex);
}
string name = outerfullname.Substring(nsIndex + 1);
TypeReference decType = new TypeReference(name, ns, asm);
for (int i = 1; i < outers.Length; i++)
{
TypeReference t = new TypeReference(outers [i], null, asm);
t.Module = m_reflectReader.Module;
t.DeclaringType = decType;
decType = t;
}
decType.Module = m_reflectReader.Module;
decType.IsValueType = true;
return(decType);
}
TypeReference ReadTypeReference(byte [] data, BinaryReader br, out ElementType elemType)
{
bool array = false;
elemType = (ElementType)br.ReadByte();
if (elemType == ElementType.SzArray)
{
elemType = (ElementType)br.ReadByte();
array = true;
}
TypeReference res;
if (elemType == ElementType.Enum)
{
res = CreateEnumTypeReference(ReadUTF8String(data, br));
}
else
{
res = TypeReferenceFromElemType(elemType);
}
if (array)
{
res = new ArrayType(res);
}
return(res);
}
TypeReference TypeReferenceFromElemType(ElementType elemType)
{
switch (elemType)
{
case ElementType.Boxed:
case ElementType.Object:
return(m_reflectReader.SearchCoreType(Constants.Object));
case ElementType.String:
return(m_reflectReader.SearchCoreType(Constants.String));
case ElementType.Type:
return(m_reflectReader.SearchCoreType(Constants.Type));
case ElementType.Boolean:
return(m_reflectReader.SearchCoreType(Constants.Boolean));
case ElementType.Char:
return(m_reflectReader.SearchCoreType(Constants.Char));
case ElementType.R4:
return(m_reflectReader.SearchCoreType(Constants.Single));
case ElementType.R8:
return(m_reflectReader.SearchCoreType(Constants.Double));
case ElementType.I1:
return(m_reflectReader.SearchCoreType(Constants.SByte));
case ElementType.I2:
return(m_reflectReader.SearchCoreType(Constants.Int16));
case ElementType.I4:
return(m_reflectReader.SearchCoreType(Constants.Int32));
case ElementType.I8:
return(m_reflectReader.SearchCoreType(Constants.Int64));
case ElementType.U1:
return(m_reflectReader.SearchCoreType(Constants.Byte));
case ElementType.U2:
return(m_reflectReader.SearchCoreType(Constants.UInt16));
case ElementType.U4:
return(m_reflectReader.SearchCoreType(Constants.UInt32));
case ElementType.U8:
return(m_reflectReader.SearchCoreType(Constants.UInt64));
default:
throw new MetadataFormatException("Non valid type in CustomAttrib.Elem: 0x{0}",
((byte)elemType).ToString("x2"));
}
}
string ResolveI18nAssembly(DirectoryAssemblyResolver resolver, string name)
{
var assembly = resolver.Resolve(AssemblyNameReference.Parse(name));
return(Path.GetFullPath(assembly.MainModule.FullyQualifiedName));
}
public AssemblyDefinition Resolve(string fullName)
{
AssemblyDefinition result = LocalResolve(fullName) ?? fallback.Resolve(AssemblyNameReference.Parse(fullName));
return(result);
}
protected override IAssemblyInfo LoadAssemblyImpl(AssemblyName assemblyName)
{
return(Wrap(assemblyResolver.Resolve(AssemblyNameReference.Parse(assemblyName.FullName))));
}
public static TypeReference GetTypeReference(this XmlType xmlType, ModuleDefinition module, IXmlLineInfo xmlInfo)
{
if (s_xmlnsDefinitions == null)
{
GatherXmlnsDefinitionAttributes();
}
var namespaceURI = xmlType.NamespaceUri;
var elementName = xmlType.Name;
var typeArguments = xmlType.TypeArguments;
var lookupAssemblies = new List <XmlnsDefinitionAttribute>();
var lookupNames = new List <string>();
foreach (var xmlnsDef in s_xmlnsDefinitions)
{
if (xmlnsDef.XmlNamespace != namespaceURI)
{
continue;
}
lookupAssemblies.Add(xmlnsDef);
}
if (lookupAssemblies.Count == 0)
{
string ns;
string typename;
string asmstring;
string targetPlatform;
XmlnsHelper.ParseXmlns(namespaceURI, out typename, out ns, out asmstring, out targetPlatform);
asmstring = asmstring ?? module.Assembly.Name.Name;
lookupAssemblies.Add(new XmlnsDefinitionAttribute(namespaceURI, ns)
{
AssemblyName = asmstring
});
}
lookupNames.Add(elementName);
lookupNames.Add(elementName + "Extension");
for (var i = 0; i < lookupNames.Count; i++)
{
var name = lookupNames[i];
if (name.Contains(":"))
{
name = name.Substring(name.LastIndexOf(':') + 1);
}
if (typeArguments != null)
{
name += "`" + typeArguments.Count; //this will return an open generic Type
}
lookupNames[i] = name;
}
TypeReference type = null;
foreach (var asm in lookupAssemblies)
{
if (type != null)
{
break;
}
foreach (var name in lookupNames)
{
if (type != null)
{
break;
}
var assemblydefinition = module.Assembly.Name.Name == asm.AssemblyName ?
module.Assembly :
module.AssemblyResolver.Resolve(AssemblyNameReference.Parse(asm.AssemblyName));
type = assemblydefinition.MainModule.GetType(asm.ClrNamespace, name);
if (type == null)
{
var exportedtype =
assemblydefinition.MainModule.ExportedTypes.FirstOrDefault(
(ExportedType arg) => arg.IsForwarder && arg.Namespace == asm.ClrNamespace && arg.Name == name);
if (exportedtype != null)
{
type = exportedtype.Resolve();
}
}
}
}
if (type != null && typeArguments != null && type.HasGenericParameters)
{
type =
module.ImportReference(type)
.MakeGenericInstanceType(typeArguments.Select(x => GetTypeReference(x, module, xmlInfo)).ToArray());
}
if (type == null)
{
throw new XamlParseException(string.Format("Type {0} not found in xmlns {1}", elementName, namespaceURI), xmlInfo);
}
return(module.ImportReference(type));
}
public TypeReference Retarget(TypeReference type, GenericContext context)
{
TypeReference reference;
if (type == null)
{
return(type);
}
if ((type.IsFunctionPointer || type.IsOptionalModifier) || type.IsSentinel)
{
throw new NotImplementedException();
}
if (type.IsArray)
{
ArrayType type2 = (ArrayType)type;
ArrayType type3 = new ArrayType(this.Retarget(type2.ElementType, context), type2.Rank);
for (int i = 0; i < type2.Dimensions.Count; i++)
{
ArrayDimension dimension = type2.Dimensions[i];
type3.Dimensions[i] = new ArrayDimension(dimension.LowerBound, dimension.UpperBound);
}
reference = type3;
}
else if (type.IsByReference)
{
ByReferenceType type4 = (ByReferenceType)type;
reference = new ByReferenceType(this.Retarget(type4.ElementType, context));
}
else if (type.IsDefinition && Utility.SameScope(type.Scope, this.Module))
{
reference = type;
}
else if (type.IsGenericInstance)
{
GenericInstanceType type5 = (GenericInstanceType)type;
GenericInstanceType type6 = new GenericInstanceType(this.Retarget(type5.ElementType, context));
foreach (TypeReference reference2 in type5.GenericArguments)
{
TypeReference item = this.Retarget(reference2, context);
type6.GenericArguments.Add(item);
}
reference = type6;
}
else
{
if (type.IsGenericParameter)
{
GenericParameter parameter = (GenericParameter)type;
return(context.Retarget(parameter));
}
if (type.IsPinned)
{
PinnedType type7 = (PinnedType)type;
reference = new PinnedType(this.Retarget(type7.ElementType, context));
}
else if (type.IsPointer)
{
PointerType type8 = (PointerType)type;
reference = new PointerType(this.Retarget(type8.ElementType, context));
}
else if (type.IsRequiredModifier)
{
RequiredModifierType type9 = (RequiredModifierType)type;
reference = new RequiredModifierType(this.Retarget(type9.ModifierType, context), this.Retarget(type9.ElementType, context));
}
else
{
reference = type.Resolve();
if ((reference == null) && (this.OperationContext.Platform == Platform.UAP))
{
string fullName = null;
string str2 = type.FullName;
if ((!(str2 == "System.Collections.ArrayList") && !(str2 == "System.Collections.CollectionBase")) && (!(str2 == "System.Collections.Hashtable") && !(str2 == "System.Collections.Stack")))
{
if (str2 == "System.Reflection.BindingFlags")
{
fullName = "System.Reflection.TypeExtensions";
}
}
else
{
fullName = "System.Collections.NonGeneric";
}
if (fullName != null)
{
IMetadataScope scope = type.Scope;
type.Scope = AssemblyNameReference.Parse(fullName);
reference = type.Resolve();
type.Scope = scope;
}
}
}
}
return(this.Module.ImportReference(reference));
}
public AssemblyList CreateDefaultList(string name, string?path = null, string?newName = null)
{
var list = new AssemblyList(this, newName ?? name);
switch (name)
{
case DotNet4List:
AddToListFromGAC("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data.DataSetExtensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Xaml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Xml.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
AddToListFromGAC("PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
break;
case DotNet35List:
AddToListFromGAC("mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data.DataSetExtensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Xml.Linq, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("PresentationCore, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
break;
case ASPDotNetMVC3List:
AddToListFromGAC("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.ComponentModel.DataAnnotations, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Configuration, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
AddToListFromGAC("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data.DataSetExtensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Data.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
AddToListFromGAC("System.EnterpriseServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
AddToListFromGAC("System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
AddToListFromGAC("System.Web.Abstractions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.ApplicationServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.DynamicData, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.Routing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
AddToListFromGAC("System.Web.WebPages, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Web.Helpers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
AddToListFromGAC("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("System.Xml.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
AddToListFromGAC("Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
break;
case object _ when path != null:
foreach (var file in Directory.GetFiles(path, "*.dll"))
{
var dllname = Path.GetFileName(file);
if (DoIncludeFile(dllname))
{
AddToListFromDirectory(file);
}
}
break;
}
return(list);
void AddToListFromGAC(string fullName)
{
AssemblyNameReference reference = AssemblyNameReference.Parse(fullName);
string?file = UniversalAssemblyResolver.GetAssemblyInGac(reference);
if (file != null)
{
list.OpenAssembly(file);
}
}
void AddToListFromDirectory(string file)
{
if (File.Exists(file))
{
list.OpenAssembly(file);
}
}
bool DoIncludeFile(string fileName)
{
if (fileName == "Microsoft.DiaSymReader.Native.amd64.dll")
{
return(false);
}
if (fileName.EndsWith("_cor3.dll", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (char.IsUpper(fileName[0]))
{
return(true);
}
if (fileName == "netstandard.dll")
{
return(true);
}
if (fileName == "mscorlib.dll")
{
return(true);
}
return(false);
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="targetPlatform">The target game platform.</param>
/// <param name="removeAssemblyNames">The assembly short names to remove (like <c>Stardew Valley</c>).</param>
/// <param name="targetAssemblies">The assemblies to target.</param>
public PlatformAssemblyMap(Platform targetPlatform, string[] removeAssemblyNames, Assembly[] targetAssemblies)
{
// save data
this.TargetPlatform = targetPlatform;
this.RemoveNames = removeAssemblyNames;
// cache assembly metadata
this.Targets = targetAssemblies;
this.TargetReferences = this.Targets.ToDictionary(assembly => assembly, assembly => AssemblyNameReference.Parse(assembly.FullName));
#if SMAPI_FOR_MOBILE
this.TargetModules = this.Targets.ToDictionary(assembly => assembly, assembly => ModuleDefinition.ReadModule(Path.Combine(Constants.ExecutionPath, assembly.Modules.Single().FullyQualifiedName), new ReaderParameters {
InMemory = true
}));
#else
this.TargetModules = this.Targets.ToDictionary(assembly => assembly, assembly => ModuleDefinition.ReadModule(assembly.Modules.Single().FullyQualifiedName, new ReaderParameters {
InMemory = true
}));
#endif
}
private void LoadTypeDefinitions()
{
var argoAssemblyDef = AssemblyResolver.Resolve(AssemblyNameReference.Parse("RedArrow.Argo"));
_hasOneAttributeTypeDef = argoAssemblyDef.MainModule.GetType("RedArrow.Argo.Attributes.HasOneAttribute");
_hasManyAttributeTypeDef = argoAssemblyDef.MainModule.GetType("RedArrow.Argo.Attributes.HasManyAttribute");
_loadStrategyTypeDef = argoAssemblyDef.MainModule.GetType("RedArrow.Argo.Attributes.LoadStrategy");
_sessionTypeDef = argoAssemblyDef.MainModule.GetType("RedArrow.Argo.Session.IModelSession");
_resourceIdentifierTypeDef = argoAssemblyDef.MainModule.GetType("RedArrow.Argo.Model.IResourceIdentifier");
_compilerGeneratedAttribute = argoAssemblyDef.MainModule
.ImportReference(typeof(CompilerGeneratedAttribute).GetConstructor(new Type[0]))
.Resolve();
_debuggerBrowsableAttribute = argoAssemblyDef.MainModule
.ImportReference(typeof(DebuggerBrowsableAttribute).GetConstructor(new[] { typeof(DebuggerBrowsableState) }))
.Resolve();
_debuggerBrowsableStateTypeDef = argoAssemblyDef.MainModule
.ImportReference(typeof(DebuggerBrowsableState))
.Resolve();
_session_DisposedGetter = _sessionTypeDef
.Properties
.Single(x => x.Name == "Disposed")
.GetMethod;
_session_GetId = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetId");
_session_GetAttribute = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetAttribute");
_session_GetReferenceId = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetReferenceId");
_session_GetReference = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetReference");
_session_GetMeta = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetMeta");
_session_GetRelationshipIds = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetRelationshipIds");
_session_GetGenericEnumerable = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetGenericEnumerable");
_session_GetGenericCollection = _sessionTypeDef
.Methods
.Single(x => x.Name == "GetGenericCollection");
_string_equals = ModuleDefinition
.TypeSystem
.String
.Resolve()
.Methods
.First(x => x.IsStatic &&
x.Name == "Equals" &&
x.Parameters.Count == 3 &&
x.Parameters[0].ParameterType.Name == "String" &&
x.Parameters[1].ParameterType.Name == "String" &&
x.Parameters[2].ParameterType.Name == "StringComparison");
_stringComparison_ordinal = (int)ModuleDefinition
.Assembly
.MainModule
.ImportReference(typeof(StringComparison))
.Resolve()
.Fields
.First(x => x.Name == "Ordinal")
.Constant;
_equalityComparerTypeDef = ModuleDefinition
.Assembly
.MainModule
.ImportReference(typeof(EqualityComparer <>))
.Resolve();
_object_equals = ModuleDefinition
.TypeSystem
.Object
.Resolve()
.Methods
.First(x => x.Name == "Equals" && x.Parameters.Count == 2);
}
// this logic produces similar list of assemblies that IL2CPP will convert (it differs in the way it collects winmd files)
public static IEnumerable <AssemblyDefinition> CollectAllAssemblies(string librariesFolder, RuntimeClassRegistry usedClasses)
{
var resolver = new DefaultAssemblyResolver();
resolver.RemoveSearchDirectory(".");
resolver.RemoveSearchDirectory("bin");
resolver.AddSearchDirectory(librariesFolder);
var usedDlls = usedClasses.GetUserAssemblies().Where(s => usedClasses.IsDLLUsed(s)).Select(file => AssemblyNameReference.Parse(Path.GetFileNameWithoutExtension(file)));
return(CollectAssembliesRecursive(usedDlls.Select(dll => ResolveAssemblyReference(resolver, dll)).Where(a => a != null)));
}
LoadedAssembly LookupReferencedAssemblyInternal(string fullName)
{
foreach (LoadedAssembly asm in assemblyList.GetAssemblies())
{
if (asm.AssemblyDefinition != null && fullName.Equals(asm.AssemblyDefinition.FullName, StringComparison.OrdinalIgnoreCase))
{
return(asm);
}
}
if (assemblyLoadDisableCount > 0)
{
return(null);
}
if (!App.Current.Dispatcher.CheckAccess())
{
// Call this method on the GUI thread.
return((LoadedAssembly)App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Func <string, LoadedAssembly>(LookupReferencedAssembly), fullName));
}
var targetFramework = TargetFrameworkId.Split(new[] { ",Version=v" }, StringSplitOptions.None);
var name = AssemblyNameReference.Parse(fullName);
string file = null;
switch (targetFramework[0])
{
case ".NETCoreApp":
case ".NETStandard":
if (targetFramework.Length != 2)
{
break;
}
if (dotNetCorePathFinder == null)
{
var version = targetFramework[1].Length == 3 ? targetFramework[1] + ".0" : targetFramework[1];
dotNetCorePathFinder = new DotNetCorePathFinder(fileName, TargetFrameworkId, version, this.loadedAssemblyReferences);
}
file = dotNetCorePathFinder.TryResolveDotNetCore(name);
break;
default:
file = GacInterop.FindAssemblyInNetGac(name);
break;
}
if (file == null)
{
string dir = Path.GetDirectoryName(this.fileName);
if (File.Exists(Path.Combine(dir, name.Name + ".dll")))
{
file = Path.Combine(dir, name.Name + ".dll");
}
else if (File.Exists(Path.Combine(dir, name.Name + ".exe")))
{
file = Path.Combine(dir, name.Name + ".exe");
}
}
if (file != null)
{
loadedAssemblyReferences.AddMessage(fullName, MessageKind.Info, "Success - Loading from: " + file);
return(assemblyList.OpenAssembly(file, true));
}
else
{
loadedAssemblyReferences.AddMessage(fullName, MessageKind.Error, "Could not find reference: " + fullName);
return(null);
}
}
public AssemblyDefinition Resolve(string fullName)
{
return(Resolve(AssemblyNameReference.Parse(fullName), null));
}
private static AssemblyDefinition OnRelinkerResolveFailure(object sender, AssemblyNameReference reference)
{
if (reference.FullName.ToLowerInvariant().Contains("fna") || reference.FullName.ToLowerInvariant().Contains("xna"))
{
AssemblyName[] asmRefs = typeof(Celeste).Assembly.GetReferencedAssemblies();
for (int ari = 0; ari < asmRefs.Length; ari++)
{
AssemblyName asmRef = asmRefs[ari];
if (!asmRef.FullName.ToLowerInvariant().Contains("xna") &&
!asmRef.FullName.ToLowerInvariant().Contains("fna") &&
!asmRef.FullName.ToLowerInvariant().Contains("monogame")
)
{
continue;
}
return(((DefaultAssemblyResolver)_Modder.AssemblyResolver).Resolve(AssemblyNameReference.Parse(asmRef.FullName)));
}
}
return(null);
}
public void RunRegistrar()
{
// The static registrar.
if (Registrar != RegistrarMode.Static)
{
throw new PlatformException(67, "Invalid registrar: {0}", Registrar); // this is only called during our own build
}
if (RootAssemblies.Count < 1)
{
throw ErrorHelper.CreateError(130, "No root assemblies found. You should provide at least one root assembly.");
}
var registrar_m = RegistrarOutputLibrary;
var RootAssembly = RootAssemblies [0];
var resolvedAssemblies = new Dictionary <string, AssemblyDefinition> ();
var resolver = new PlatformResolver()
{
FrameworkDirectory = Driver.GetPlatformFrameworkDirectory(this),
RootDirectory = Path.GetDirectoryName(RootAssembly),
#if MMP
CommandLineAssemblies = RootAssemblies,
#endif
};
if (Platform == ApplePlatform.iOS || Platform == ApplePlatform.MacOSX)
{
if (Is32Build)
{
resolver.ArchDirectory = Driver.GetArch32Directory(this);
}
else
{
resolver.ArchDirectory = Driver.GetArch64Directory(this);
}
}
var ps = new ReaderParameters();
ps.AssemblyResolver = resolver;
resolvedAssemblies.Add("mscorlib", ps.AssemblyResolver.Resolve(AssemblyNameReference.Parse("mscorlib"), new ReaderParameters()));
var productAssembly = Driver.GetProductAssembly(this);
bool foundProductAssembly = false;
foreach (var asm in RootAssemblies)
{
var rootName = Path.GetFileNameWithoutExtension(asm);
if (rootName == productAssembly)
{
foundProductAssembly = true;
}
try {
AssemblyDefinition lastAssembly = ps.AssemblyResolver.Resolve(AssemblyNameReference.Parse(rootName), new ReaderParameters());
if (lastAssembly == null)
{
ErrorHelper.CreateWarning(7, "The root assembly '{0}' does not exist", rootName);
continue;
}
if (resolvedAssemblies.TryGetValue(rootName, out var previousAssembly))
{
if (lastAssembly.MainModule.RuntimeVersion != previousAssembly.MainModule.RuntimeVersion)
{
Driver.Log(2, "Attemping to load an assembly another time {0} (previous {1})", lastAssembly.FullName, previousAssembly.FullName);
}
continue;
}
resolvedAssemblies.Add(rootName, lastAssembly);
Driver.Log(3, "Loaded {0}", lastAssembly.MainModule.FileName);
} catch (Exception ex) {
ErrorHelper.Warning(9, ex, "Error while loading assemblies: {0}: {1}", rootName, ex.Message);
continue;
}
}
if (!foundProductAssembly)
{
throw ErrorHelper.CreateError(131, "Product assembly '{0}' not found in assembly list: '{1}'", productAssembly, string.Join("', '", RootAssemblies.ToArray()));
}
#if MONOTOUCH
BuildTarget = BuildTarget.Simulator;
#endif
var registrar = new Registrar.StaticRegistrar(this);
if (RootAssemblies.Count == 1)
{
registrar.GenerateSingleAssembly(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m, Path.GetFileNameWithoutExtension(RootAssembly));
}
else
{
registrar.Generate(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m);
}
}
public AssemblyDefinition Resolve(string fullName)
{
return(Resolve(AssemblyNameReference.Parse(fullName), new ReaderParameters {
AssemblyResolver = this
}));
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
return(Resolve(AssemblyNameReference.Parse(fullName), parameters));
}
Assembly LoadI18nAssembly(string name)
{
var assembly = ManifestResolver.Resolve(AssemblyNameReference.Parse(name));
return(new Assembly(this, assembly));
}
static AssemblyNameReference GetAssemblyName(XPathNavigator nav)
{
return(AssemblyNameReference.Parse(GetAttribute(nav, "fullname")));
}
static TypeDefinition ResolveXmlns(string xmlNamespace, string typeName, AssemblyDefinition context, IEnumerable <AssemblyDefinition> asms)
{
typeName = typeName.Replace('+', '/');
if (xmlNamespace.StartsWith("clr-namespace:"))
{
string ns, asmName;
SplitClrNsUri(xmlNamespace, out ns, out asmName);
AssemblyDefinition asm;
if (asmName == null)
{
asm = context;
}
else
{
asmName = AssemblyNameReference.Parse(asmName).Name;
if (asmName == context.Name.Name)
{
asm = context;
}
else
{
asm = asms.SingleOrDefault(_ => _.Name.Name == asmName);
}
}
if (asm != null)
{
if (string.IsNullOrEmpty(ns))
{
return(asm.MainModule.GetType(typeName));
}
else
{
return(asm.MainModule.GetType(string.Format("{0}.{1}", ns, typeName)));
}
}
}
else
{
foreach (var i in asms)
{
foreach (var attr in i.CustomAttributes.Where(_ => _.AttributeType.FullName == "System.Windows.Markup.XmlnsDefinitionAttribute"))
{
string uri = attr.ConstructorArguments[0].Value as string;
string clrNs = attr.ConstructorArguments[1].Value as string;
if (uri == xmlNamespace)
{
TypeDefinition typeDef;
if (string.IsNullOrEmpty(clrNs))
{
typeDef = i.MainModule.GetType(typeName);
}
else
{
typeDef = i.MainModule.GetType(string.Format("{0}.{1}", clrNs, typeName));
}
if (typeDef != null)
{
return(typeDef);
}
}
}
}
}
return(null);
}
protected virtual AssemblyNameReference GetAssemblyName(XPathNavigator nav)
{
return(AssemblyNameReference.Parse(GetFullName(nav)));
}
private void ProcessBaml(ModuleDefinition mod, Dictionary <string, BamlDocument> bamls, ref int cc, DictionaryEntry entry, Stream stream)
{
cc++;
docName = entry.Key as string;
doc = BamlReader.ReadDocument(stream);
(mod as IAnnotationProvider).Annotations[RenMode] = NameMode.Letters;
for (int i = 0; i < doc.Count; i++)
{
if (doc[i] is LineNumberAndPositionRecord || doc[i] is LinePositionRecord)
{
doc.RemoveAt(i); i--;
}
}
int asmId = -1;
Dictionary <ushort, AssemblyDefinition> asms = new Dictionary <ushort, AssemblyDefinition>();
foreach (var rec in doc.OfType <AssemblyInfoRecord>())
{
AssemblyNameReference nameRef = AssemblyNameReference.Parse(rec.AssemblyFullName);
if (nameRef.Name == mod.Assembly.Name.Name)
{
asmId = rec.AssemblyId;
rec.AssemblyFullName = GetBamlAssemblyFullName(mod.Assembly.Name);
asms.Add(rec.AssemblyId, mod.Assembly);
PopulateMembers(mod.Assembly);
nameRef = null;
}
else
{
bool added = false;
foreach (var i in ivtMap)
{
if (i.Key.Name.Name == nameRef.Name)
{
rec.AssemblyFullName = GetBamlAssemblyFullName(i.Key.Name);
asms.Add(rec.AssemblyId, i.Key);
PopulateMembers(i.Key);
nameRef = null;
added = true;
break;
}
}
if (!added)
{
var asmRefDef = GlobalAssemblyResolver.Instance.Resolve(nameRef);
if (asmRefDef != null)
{
PopulateMembers(asmRefDef);
}
}
}
}
Dictionary <ushort, TypeDefinition> types = new Dictionary <ushort, TypeDefinition>();
foreach (var rec in doc.OfType <TypeInfoRecord>())
{
AssemblyDefinition asm;
if (asms.TryGetValue((ushort)(rec.AssemblyId & 0xfff), out asm))
{
TypeReference type = TypeParser.ParseType(asm.MainModule, rec.TypeFullName);
if (type != null)
{
types.Add(rec.TypeId, type.Resolve());
AddTypeRenRefs(type, type, rec);
rec.TypeFullName = TypeParser.ToParseable(type);
}
}
}
Dictionary <string, string> xmlns = new Dictionary <string, string>();
foreach (var rec in doc.OfType <XmlnsPropertyRecord>())
{
xmlns[rec.Prefix] = rec.XmlNamespace;
}
Dictionary <ushort, string> ps = new Dictionary <ushort, string>();
foreach (var rec in doc.OfType <AttributeInfoRecord>())
{
if (types.ContainsKey(rec.OwnerTypeId))
{
PropertyDefinition prop = types[rec.OwnerTypeId].Properties.SingleOrDefault(p => p.Name == rec.Name);
if (prop != null)
{
((prop as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlAttributeReference(rec));
}
EventDefinition evt = types[rec.OwnerTypeId].Events.SingleOrDefault(p => p.Name == rec.Name);
if (evt != null)
{
((evt as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlAttributeReference(rec));
}
FieldDefinition field = types[rec.OwnerTypeId].Fields.SingleOrDefault(p => p.Name == rec.Name);
if (field != null)
{
((field as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlAttributeReference(rec));
}
//Attached property
MethodDefinition getM = types[rec.OwnerTypeId].Methods.SingleOrDefault(p => p.Name == "Get" + rec.Name);
if (getM != null)
{
(getM as IAnnotationProvider).Annotations[RenOk] = false;
}
MethodDefinition setM = types[rec.OwnerTypeId].Methods.SingleOrDefault(p => p.Name == "Set" + rec.Name);
if (setM != null)
{
(setM as IAnnotationProvider).Annotations[RenOk] = false;
}
}
ps.Add(rec.AttributeId, rec.Name);
}
foreach (var rec in doc.OfType <PropertyWithConverterRecord>())
{
if (rec.ConverterTypeId == 0xfd4c || ((short)rec.AttributeId > 0 && ps[rec.AttributeId] == "TypeName")) //TypeExtension
{
string type = rec.Value;
string xmlNamespace;
if (type.IndexOf(':') != -1)
{
xmlNamespace = xmlns[type.Substring(0, type.IndexOf(':'))];
type = type.Substring(type.IndexOf(':') + 1, type.Length - type.IndexOf(':') - 1);
}
else
{
xmlNamespace = xmlns[""];
}
TypeDefinition typeDef;
if ((typeDef = ResolveXmlns(xmlNamespace, type, mod.Assembly, asms.Values)) != null)
{
((typeDef as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlTypeExtReference(rec, doc, typeDef.Module.Assembly.Name.Name));
}
}
if (rec.ConverterTypeId == 0xff77 || rec.ConverterTypeId == 0xfe14 || rec.ConverterTypeId == 0xfd99)
{
ProcessProperty(rec, rec.Value);
}
}
for (int i = 1; i < doc.Count; i++)
{
ElementStartRecord binding = doc[i - 1] as ElementStartRecord;
ConstructorParametersStartRecord param = doc[i] as ConstructorParametersStartRecord;
if (binding != null && param != null && binding.TypeId == 0xffec)//Binding
{
TextRecord path = doc[i + 1] as TextRecord;
ProcessProperty(path, path.Value);
}
}
var rootRec = doc.OfType <ElementStartRecord>().FirstOrDefault();
if (rootRec != null && types.ContainsKey(rootRec.TypeId))
{
TypeDefinition root = types[rootRec.TypeId];
Dictionary <string, IMemberDefinition> m = new Dictionary <string, IMemberDefinition>();
foreach (PropertyDefinition prop in root.Properties)
{
m.Add(prop.Name, prop);
}
foreach (EventDefinition evt in root.Events)
{
m.Add(evt.Name, evt);
}
//foreach (MethodDefinition mtd in root.Methods)
// mems.Add(mtd.Name, mtd);
foreach (var rec in doc.OfType <PropertyRecord>())
{
if (!(rec.Value is string))
{
continue;
}
if (m.ContainsKey((string)rec.Value))
{
((m[(string)rec.Value] as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(new BamlPropertyReference(rec));
}
}
}
bamls.Add(entry.Key as string, doc);
}
public void ExportedTypeFromModule()
{
var resolver = new CustomResolver();
var parameters = new ReaderParameters {
AssemblyResolver = resolver
};
var mma = GetResourceModule("mma.exe", parameters);
resolver.Register(mma.Assembly);
var current_module = GetCurrentModule(parameters);
var reference = new TypeReference("Module.A", "Foo", current_module, AssemblyNameReference.Parse(mma.Assembly.FullName), false);
var definition = reference.Resolve();
Assert.IsNotNull(definition);
Assert.AreEqual("Module.A.Foo", definition.FullName);
}
public virtual AssemblyDefinition Resolve(string fullName)
{
return(this.Resolve(AssemblyNameReference.Parse(fullName)));
}
/// <summary>
/// Resolve an assembly by name.
/// </summary>
public AssemblyDefinition Resolve(string fullName)
{
var name = AssemblyNameReference.Parse(fullName);
return(Resolve(name));
}
public static AssemblyDefinition GetAssembly(this IAssemblyResolver resolver, string fileName)
{
return(resolver.Resolve(AssemblyNameReference.Parse(Path.GetFileNameWithoutExtension(fileName))));
}
