IAssemblyResolver GetAssemblyResolver()
{
if (test_case.AssemblyResolver != null)
{
return(test_case.AssemblyResolver);
}
test_resolver = new DefaultAssemblyResolver();
var directory = Path.GetDirectoryName(test_case.ModuleLocation);
test_resolver.AddSearchDirectory(directory);
return(test_resolver);
}
/// <summary>
/// Returns a new assembly resolver.
/// </summary>
private IAssemblyResolver GetAssemblyResolver()
{
// TODO: can we reuse it, or do we need a new one for each assembly?
var assemblyResolver = new DefaultAssemblyResolver();
// Add known search directories for resolving assemblies.
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(typeof(ControlledTask).Assembly.Location));
assemblyResolver.AddSearchDirectory(this.Configuration.AssembliesDirectory);
// Add the assembly resolution error handler.
assemblyResolver.ResolveFailure += OnResolveAssemblyFailure;
return(assemblyResolver);
}
private void LoadModules()
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(_file.DirectoryName);
var parameters = new ReaderParameters
{
AssemblyResolver = resolver,
};
_module = ModuleDefinition.ReadModule(_file.FullName, parameters);
}
public CecilSymbolHelperTests()
{
var location = GetType().Assembly.Location;
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(location));
var parameters = new ReaderParameters {
ReadSymbols = true, AssemblyResolver = resolver
};
_module = ModuleDefinition.ReadModule(location, parameters);
_cecilSymbolHelper = new CecilSymbolHelper();
}
private static AssemblyDefinition[] LoadAssemblies(string packageDirectory)
{
var assemblyDirectory = PathConstruction.Combine(packageDirectory, "tools");
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(assemblyDirectory);
return(PathConstruction.GlobFiles(assemblyDirectory, "docfx.exe")
.Select(x => AssemblyDefinition.ReadAssembly(x, new ReaderParameters {
AssemblyResolver = assemblyResolver
}))
.ToArray());
}
public DllMerger(MergeOptions options)
{
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(options.Executable));
var assembly = AssemblyDefinition.ReadAssembly(options.Executable, new ReaderParameters()
{
AssemblyResolver = assemblyResolver
});
_assembly = assembly;
_options = options;
}
private static AssemblyDefinition GetAssembly(string location)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(typeof(IPropertyContainer).Assembly.Location));
return(AssemblyDefinition.ReadAssembly(
location,
new ReaderParameters()
{
AssemblyResolver = resolver
}));
}
private static ReaderParameters GetReaderParameters(string folder)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(folder);
var parameters = new ReaderParameters
{
AssemblyResolver = resolver,
};
return(parameters);
}
public void InitializeTest()
{
if (!initialized)
{
var weaver = new NotificationWeaver(TestNotifierPath);
weaver.InsertNotifications(true);
initialized = true;
}
this.assemblyResolver = new DefaultAssemblyResolver();
this.assemblyResolver.AddSearchDirectory(ApplicationPath);
this.metadataResolver = new MetadataResolver(assemblyResolver);
}
public ModuleDefinition ReadModuleDefinition(string path)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(ManagedFolder);
ModuleDefinition module = ModuleDefinition.ReadModule(path, new ReaderParameters()
{
AssemblyResolver = resolver,
});
return(module);
}
protected ModuleDefinition read_module(string path, bool readOnly)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(path));
var rp = new ReaderParameters {
ReadWrite = !readOnly,
AssemblyResolver = resolver
};
return(ModuleDefinition.ReadModule(path, rp));
}
void patch_dll()
{
try
{
var temp_path = temp_base + "patch.dll";
File.Copy(dll_path, temp_path, true);
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(dlls_path);
var reader = new ReaderParameters()
{
AssemblyResolver = resolver
};
var game_dll = AssemblyDefinition.ReadAssembly(temp_path, reader).MainModule;
var welcome = game_dll.Types.Single(t => t.Name == "WelcomeScript");
var labels = welcome.Resolve().Fields.Single(f => f.Name == "FlashingLabels");
labels.IsPrivate = false;
labels.IsPublic = true;
labels.Attributes = Mono.Cecil.FieldAttributes.Public;
var csharp_dll = AssemblyDefinition.ReadAssembly(dlls_path + "Assembly-CSharp-firstpass.dll", reader);
var ui_label = csharp_dll.MainModule.Types.Single(t => t.Name == "UILabel");
var set_text = ui_label.Methods.Single(m => m.Name == "set_text");
var setref = game_dll.ImportReference(set_text);
var start = welcome.Methods.Single(m => m.Name == "Start");
var il2 = start.Body.GetILProcessor();
il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Callvirt, setref));
il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldstr, "Warning ! Do not submit bug reports, Yandere Loader is loaded !"));
il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldelem_Ref));
il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldc_I4_2));
il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldfld, labels));
il2.InsertBefore(start.Body.Instructions[0], il2.Create(OpCodes.Ldarg_0));
game_dll.Write(dll_path);
}
catch (Exception e)
{
write_line("[CRITICAL]: Failed to patch dll: " + e.ToString());
Application.Exit();
}
}
public IEnumerable <SdkFunctionMetadata> GenerateFunctionMetadata(string assemblyPath, IEnumerable <string> referencePaths)
{
string sourcePath = Path.GetDirectoryName(assemblyPath);
string[] targetAssemblies = Directory.GetFiles(sourcePath, "*.dll");
var functions = new List <SdkFunctionMetadata>();
_logger.LogMessage($"Found { targetAssemblies.Length} assemblies to evaluate in '{sourcePath}':");
foreach (var path in targetAssemblies)
{
using (_logger.Indent())
{
_logger.LogMessage($"{Path.GetFileName(path)}");
using (_logger.Indent())
{
try
{
BaseAssemblyResolver resolver = new DefaultAssemblyResolver();
foreach (string referencePath in referencePaths.Select(p => Path.GetDirectoryName(p)).Distinct())
{
resolver.AddSearchDirectory(referencePath);
}
resolver.AddSearchDirectory(Path.GetDirectoryName(path));
ReaderParameters readerParams = new ReaderParameters {
AssemblyResolver = resolver
};
var moduleDefintion = ModuleDefinition.ReadModule(path, readerParams);
functions.AddRange(GenerateFunctionMetadata(moduleDefintion));
}
catch (BadImageFormatException)
{
_logger.LogMessage($"Skipping file '{Path.GetFileName(path)}' because of a {nameof(BadImageFormatException)}.");
}
catch (Exception ex)
{
_logger.LogWarning($"Could not evaluate '{Path.GetFileName(path)}' for functions metadata. Exception message: {ex.ToString()}");
}
}
}
}
return(functions);
}
public static RuntimeInitializeOnLoadMethodsData ExtractPlayerRuntimeInitializeOnLoadMethods(BuildTarget targetPlatform, string[] assemblyPaths, string[] searchDirs)
{
var classInfoList = new List <RuntimeInitializeClassInfo>();
int methodCount = 0;
foreach (var assemblyPath in assemblyPaths)
{
try
{
var assemblyResolverData = new GetAssemblyResolverData {
SearchDirs = searchDirs,
};
var resolver = new DefaultAssemblyResolver();
foreach (var searchDir in searchDirs)
{
resolver.AddSearchDirectory(searchDir);
}
assemblyResolverData.Resolver = resolver;
var assembly = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters
{
AssemblyResolver = assemblyResolverData.Resolver
});
var assemblyName = assembly.Name.Name;
foreach (var module in assembly.Modules)
{
foreach (var type in module.Types)
{
FindRuntimeInitializeOnLoadMethodAttributes(type,
assemblyName,
ref classInfoList,
ref methodCount);
}
}
}
catch (Exception ex)
{
throw new Exception("ExtractPlayerRuntimeInitializeOnLoadMethods: Failed to process " + assemblyPath + ", " + ex);
}
}
var data = new RuntimeInitializeOnLoadMethodsData();
data.classInfos = classInfoList.ToArray();
data.methodsCount = methodCount;
return(data);
}
public static void addProfiler(string assemblyPath, string fileName, string typeName, string methodName)
{
if (Application.isPlaying || EditorApplication.isCompiling)
{
Debug.Log("You need stop play mode or wait compiling finished");
return;
}
if (!System.IO.File.Exists(assemblyPath + fileName))
{
Debug.Log("This Project didn't contains this dll");
return;
}
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(assemblyPath);
var readerParameters = new ReaderParameters {
ReadSymbols = false, AssemblyResolver = resolver
};
var assembly = AssemblyDefinition.ReadAssembly(assemblyPath + fileName, readerParameters);
if (assembly == null)
{
Debug.LogError("InjectTool Inject Load assembly failed: " + assemblyPath);
return;
}
try
{
ProcessAssembly(assembly, typeName, methodName);
assembly.Write(assemblyPath + fileName, new WriterParameters {
WriteSymbols = false
});
Debug.Log("Listening function " + methodName + " successfully!");
}
catch (Exception ex)
{
Debug.LogError("InjectTool addProfiler failed: " + ex);
throw;
}
finally
{
if (assembly.MainModule.SymbolReader != null)
{
Debug.Log("InjectTool addProfiler Succeed");
assembly.MainModule.SymbolReader.Dispose();
}
}
// Debug.Log("InjectTool Inject" + fileName + " End");
}
static void Main()
{
string managedPath = PathDiscovery.FindManagedDirectory();
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(managedPath);
Version version = GetUnityVersion();
// as of Unity 2017.2, the UnityEngine assembly has been split into multiple assemblies
// the assembly containing the GameObject class is UnityEngine.CoreModule
string coreName = version.Major < 2017 || (version.Major == 2017 && version.Minor == 1)
? "UnityEngine"
: "UnityEngine.CoreModule";
string corePath = PathDiscovery.GetAssemblyPath(resolver, coreName);
byte[] coreData = File.ReadAllBytes(corePath);
Console.WriteLine("Unity {0} detected.", version);
ModuleDefinition unityCore = ModuleDefinition.ReadModule(
new MemoryStream(coreData),
new ReaderParameters {
AssemblyResolver = resolver
});
TypeDefinition gameObject = unityCore.GetType("UnityEngine", "GameObject");
// UPM works by adding a static constructor to the GameObject class,
// which calls an initialization function in PluginManager.Core
SetStaticCtor(gameObject, GenStaticCtor(unityCore, il =>
{
ModuleDefinition upm = ModuleDefinition.ReadModule(CoreLibrary);
TypeDefinition upmMain = upm.GetType("PluginManager.Core", "PluginManager");
MethodDefinition upmInit = upmMain.Methods.Single(m => m.Name == "Initialize");
il.Emit(OpCodes.Call, unityCore.ImportReference(upmInit));
il.Emit(OpCodes.Ret);
upm.Dispose();
}));
unityCore.Write(corePath);
// We need to copy PluginManager.Core.dll into the Managed directory
File.Copy(CoreLibrary, Path.Combine(managedPath, CoreLibrary), true);
Console.WriteLine("UPM installed.");
}
public void Execute()
{
if (!string.IsNullOrEmpty(AddinDirectoryPath)) //it is not empty when triggered from MS Build (Fody)
{
List <string> localRefDirs = new List <string>();
foreach (var refCopyLocalPath in ReferenceCopyLocalPaths)
{
localRefDirs.Add(Directory.GetParent(refCopyLocalPath).FullName);
}
var defAssemblyResolver = new DefaultAssemblyResolver();
defAssemblyResolver.AddSearchDirectory(AddinDirectoryPath);
localRefDirs.ForEach(refDir => defAssemblyResolver.AddSearchDirectory(refDir));
AssemblyResolver = defAssemblyResolver;
}
else //for testing
{
AssemblyResolver = ModuleDefinition.AssemblyResolver;
}
ReferencedModules = new List <ModuleDefinition>();
foreach (var assemblyRef in ModuleDefinition.AssemblyReferences)
{
var refModuleDefinition = AssemblyResolver.Resolve(assemblyRef).MainModule;
ReferencedModules.Add(refModuleDefinition);
}
TestFlaskAspectsModule = ResolveTestFlaskAspectsModuleDefinition();
typeSystem = ModuleDefinition.TypeSystem;
var playableMethods = ModuleDefinition.GetAllTypes().SelectMany(
t => t.Methods.Where(
md => md.CustomAttributes.Any(ca => ca.AttributeType.Name.Equals("PlaybackAttribute")))
).ToList();
foreach (var playableMethod in playableMethods)
{
var playbackAttr = playableMethod.CustomAttributes.Single(ca => ca.AttributeType.Name.Equals("PlaybackAttribute"));
TypeDefinition requestIdentifierTypeDef = playbackAttr.ConstructorArguments[0].Value as TypeDefinition;
TypeDefinition responseIdentifierTypeDef = playbackAttr.ConstructorArguments[1].Value as TypeDefinition;
var clonePlayableMethod = CloneOriginalMethod(playableMethod);
DecorateMethod(playableMethod, clonePlayableMethod, requestIdentifierTypeDef, responseIdentifierTypeDef);
}
}
//[PostProcessScene]//打包的时候会自动调用下面方法注入代码
static void AssemblyPostProcessorRun()
{
try
{
Debug.Log("AssemblyPostProcessor running");
EditorApplication.LockReloadAssemblies();
DefaultAssemblyResolver assemblyResolver = new DefaultAssemblyResolver();
foreach (System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assembly.Location));
}
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(EditorApplication.applicationPath) + "/Data/Managed");
ReaderParameters readerParameters = new ReaderParameters();
readerParameters.AssemblyResolver = assemblyResolver;
WriterParameters writerParameters = new WriterParameters();
foreach (String assemblyPath in assemblyPathss)
{
readerParameters.ReadSymbols = true;
readerParameters.SymbolReaderProvider = new Mono.Cecil.Mdb.MdbReaderProvider();
writerParameters.WriteSymbols = true;
writerParameters.SymbolWriterProvider = new Mono.Cecil.Mdb.MdbWriterProvider();
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters);
Debug.Log("Processing " + Path.GetFileName(assemblyPath));
if (HookEditor.ProcessAssembly(assemblyDefinition))
{
Debug.Log("Writing to " + assemblyPath);
assemblyDefinition.Write(assemblyPath, writerParameters);
Debug.Log("Done writing");
}
else
{
Debug.Log(Path.GetFileName(assemblyPath) + " didn't need to be processed");
}
}
}
catch (Exception e)
{
Debug.LogWarning(e);
}
EditorApplication.UnlockReloadAssemblies();
}
// It's important that this logic remains in a separate function,
// otherwise the Mono.Cecil and GamePluginKit.API assemblies
// will be resolved before the custom resolver is registered.
static void LoadPluginAssemblies(Transform root, string directory, SearchOption searchOption)
{
using (var resolver = new DefaultAssemblyResolver())
{
foreach (string searchPath in SearchPaths)
{
resolver.AddSearchDirectory(searchPath);
}
var readParams = new ReaderParameters
{
AssemblyResolver = resolver
};
foreach (string filePath in Directory.GetFiles(directory, "*.dll", searchOption))
{
// Mono.Cecil is used to inspect the attributes for a very important reason.
// If a plugin assembly contains attributes that are not present in the game's
// assemblies (for example, TargetFrameworkAttribute when using the old Mono runtime)
// the game will throw an exception when calling Assembly.GetCustomAttributes.
using (var asmDef = AssemblyDefinition.ReadAssembly(filePath, readParams))
{
var assembly = Assembly.LoadFrom(filePath);
foreach (var attribute in asmDef.CustomAttributes)
{
try
{
if (attribute.AttributeType.FullName != "GamePluginKit.StartupBehaviourAttribute")
{
continue;
}
// Retrieve the behaviour type
var typeRef = attribute.ConstructorArguments[0].Value as TypeReference;
var typeName = Assembly.CreateQualifiedName(typeRef.Module.Assembly.FullName, typeRef.FullName);
var behaviour = Type.GetType(typeName);
new GameObject(behaviour.Name, behaviour).transform.SetParent(root);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
}
}
}
internal void Compile(string assembly)
{
resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(assembly));
var basm = AssemblyDefinition.ReadAssembly(assembly, new ReaderParameters {
AssemblyResolver = resolver
});
var allasm = FindRefs(basm);
foreach (var asm in allasm)
{
WriteLine(asm.FullName);
}
}
public static AssemblyDef LoadFrom(string path)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(path));
var assemblyDef = AssemblyDefinition.ReadAssembly(
path,
new ReaderParameters {
AssemblyResolver = resolver
});
return(new AssemblyDef(assemblyDef.MainModule));
}
public void ApplyToAssembly(Stream assemblyStream)
{
var assemblyResolver = new DefaultAssemblyResolver();
var assemblyDefinitions = new Dictionary <string, AssemblyDefinition>(StringComparer.OrdinalIgnoreCase);
foreach (var assemblyName in Instance.GetAssembliesForScanning())
{
var assembly = assemblyResolver.Resolve(new AssemblyNameReference(assemblyName, null));
if (assembly == null)
{
continue;
}
if (assemblyDefinitions.ContainsKey(assemblyName))
{
continue;
}
assemblyDefinitions.Add(assemblyName, assembly);
}
TypeResolver.Initialise(assemblyDefinitions.Values);
var module = ModuleDefinition.ReadModule(assemblyStream);
Instance.ModuleDefinition = module;
Instance.FindType = TypeResolver.FindType;
Instance.TryFindType = TypeResolver.TryFindType;
Instance.ResolveAssembly = assemblyName =>
assemblyResolver.Resolve(new AssemblyNameReference(assemblyName, null));
var errors = new List <string>();
Instance.LogError = s =>
{
Debug.WriteLine($" Error: {s}");
errors.Add(s);
};
Instance.LogWarning = s => Debug.WriteLine($" Warning: {s}");
Instance.LogInfo = s => Debug.WriteLine($" Info: {s}");
Instance.LogDebug = s => Debug.WriteLine($" Debug: {s}");
Instance.Execute();
if (errors.Any())
{
throw new WeaverErrorException(errors);
}
Instance.AfterWeaving();
assemblyStream.Position = 0;
module.Write(assemblyStream);
}
static void Main(string[] args)
{
var resolver = new DefaultAssemblyResolver();
var module = resolver.Resolve(Assembly.GetExecutingAssembly().FullName).MainModule;
Console.WriteLine("For HelperClass<>");
var helperClass = module.Import(typeof(HelperClass <>)).Resolve();
var someMethod = helperClass.Methods[0];
var someMethodBody = someMethod.Body;
foreach (var instruction in someMethodBody.Instructions)
{
Console.WriteLine(
"{0}\t{1}\t{2}",
instruction.Offset,
instruction.OpCode.Code,
instruction.Operand == null ? "<null>" : string.Format("{0} / {1}", instruction.Operand.GetType().FullName, instruction.Operand.ToString()));
var fieldReference = instruction.Operand as FieldReference;
if (fieldReference != null)
{
var fieldDefinition = fieldReference.Resolve();
Console.WriteLine(
"\t\tResolved field reference operand: {0} / {1}",
fieldDefinition.GetType().FullName,
fieldDefinition.ToString());
}
}
Console.WriteLine("");
Console.WriteLine("For HelperClass<int>");
helperClass = module.Import(typeof(HelperClass <int>)).Resolve();
someMethod = helperClass.Methods[0];
someMethodBody = someMethod.Body;
foreach (var instruction in someMethodBody.Instructions)
{
Console.WriteLine(
"{0}\t{1}\t{2}",
instruction.Offset,
instruction.OpCode.Code,
instruction.Operand == null ? "<null>" : string.Format("{0} / {1}", instruction.Operand.GetType().FullName, instruction.Operand.ToString()));
var fieldReference = instruction.Operand as FieldReference;
if (fieldReference != null)
{
var fieldDefinition = fieldReference.Resolve();
Console.WriteLine(
"\t\tResolved field reference operand: {0} / {1}",
fieldDefinition.GetType().FullName,
fieldDefinition.ToString());
}
}
}
public void Variant()
{
var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "ScriptBuilder.Tests.dll");
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(TestContext.CurrentContext.TestDirectory);
var readerParameters = new ReaderParameters(ReadingMode.Deferred)
{
AssemblyResolver = assemblyResolver
};
var module = ModuleDefinition.ReadModule(path, readerParameters);
ObjectApprover.VerifyWithJson(SqlVariantReader.Read(module).ToList());
}
/// <summary>
/// Writes the module <paramref name="module"/> to the file specified by the path <paramref name="moduleFilePath"/>
/// </summary>
/// <param name="module"></param>
/// <param name="moduleFilePath"></param>
public static void WriteModule(ModuleDefinition module, String moduleFilePath)
{
// Quick fix for AssemblyResolutionException
// occurring in RequestReduce and Newtonsoft.Json projects
// detailed info documented in challenges.txt
// TODO: Check if there is more elegant solution
if (module.AssemblyResolver is DefaultAssemblyResolver)
{
DefaultAssemblyResolver resolver = module.AssemblyResolver as DefaultAssemblyResolver;
resolver.AddSearchDirectory(System.IO.Path.GetDirectoryName(module.FullyQualifiedName));
}
module.Write(moduleFilePath);
UpdateModuleDictionary(module, moduleFilePath);
}
public static IEnumerable <ExtensionReference> GenerateExtensionReferences(string fileName, ConsoleLogger logger)
{
BaseAssemblyResolver resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(fileName));
ReaderParameters readerParams = new ReaderParameters {
AssemblyResolver = resolver
};
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(fileName, readerParams);
var startupAttributes = assembly.Modules.SelectMany(p => p.GetCustomAttributes())
.Where(a => IsWebJobsStartupAttributeType(a.AttributeType, logger));
List <ExtensionReference> extensionReferences = new List <ExtensionReference>();
foreach (var attribute in startupAttributes)
{
var typeProperty = attribute.ConstructorArguments.ElementAtOrDefault(0);
var nameProperty = attribute.ConstructorArguments.ElementAtOrDefault(1);
TypeDefinition typeDef = (TypeDefinition)typeProperty.Value;
string assemblyQualifiedName = Assembly.CreateQualifiedName(typeDef.Module.Assembly.FullName, GetReflectionFullName(typeDef));
string name;
// Because we're now using static analysis we can't rely on the constructor running so have to get the name ourselves.
if (string.Equals(attribute.AttributeType.FullName, FunctionsStartupAttributeType, StringComparison.OrdinalIgnoreCase))
{
// FunctionsStartup always uses the type name as the name.
name = typeDef.Name;
}
else
{
// WebJobsStartup does some trimming.
name = GetName((string)nameProperty.Value, typeDef);
}
var extensionReference = new ExtensionReference
{
Name = name,
TypeName = assemblyQualifiedName
};
extensionReferences.Add(extensionReference);
}
return(extensionReferences);
}
public void RunInject(string assemblyPath, string assemblyName)
{
OnProgressChanged(assemblyName, 0f);
string fullName = Utility.Path.GetCombinePath(assemblyPath, assemblyName);
if (!File.Exists(fullName))
{
Debug.LogWarning(string.Format("Assembly '{0}' does not exist.", fullName));
return;
}
DefaultAssemblyResolver resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(fullName));
ModuleDefinition moduleDefinition = ModuleDefinition.ReadModule(fullName, new ReaderParameters {
AssemblyResolver = resolver
});
Collection <TypeDefinition> typeDefinitions = moduleDefinition.Types;
int typeCount = typeDefinitions.Count;
if (typeCount <= 0)
{
return;
}
int index = 0;
foreach (TypeDefinition typeDefinition in typeDefinitions)
{
if (NeedInject(typeDefinition))
{
Collection <MethodDefinition> methodDefinitions = typeDefinition.Methods;
foreach (MethodDefinition methodDefinition in methodDefinitions)
{
if (NeedInject(methodDefinition))
{
InjectMethod(typeDefinition, methodDefinition);
}
}
}
OnProgressChanged(assemblyName, ++index / (float)typeCount);
}
moduleDefinition.Write(fullName, new WriterParameters {
WriteSymbols = true
});
}
/// <summary>
/// 获取程序集反射器
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public MonoAssemblyReflector LoadAssembly(string path)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(path));
var reader = new ReaderParameters()
{
AssemblyResolver = resolver
};
var assembly = AssemblyDefinition.ReadAssembly(path, reader);
return(new MonoAssemblyReflector(assembly));
}
// Well played assembly resolver, you have escaped death this time
public static IAssemblyResolver GetAssemblyResolver()
{
DefaultAssemblyResolver resolver = new DefaultAssemblyResolver();
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
foreach (string xnaDirectory in xnaDirectories)
{
resolver.AddSearchDirectory(GetDirectoryFromGAC(xnaDirectory));
}
}
return(resolver);
}
void RunTest(string name, string asmPath, string sourcePath)
{
var resolver = new DefaultAssemblyResolver();
var assembly = AssemblyDefinition.ReadAssembly(asmPath, new ReaderParameters {
AssemblyResolver = resolver, InMemory = true
});
Resource res = assembly.MainModule.Resources.First();
Stream bamlStream = LoadBaml(res, name + ".baml");
Assert.IsNotNull(bamlStream);
XDocument document = BamlResourceEntryNode.LoadIntoDocument(resolver, assembly, bamlStream, CancellationToken.None);
XamlIsEqual(File.ReadAllText(sourcePath), document.ToString());
}
protected virtual ICollection<IUnitTestElement> GetUnitTestElements(IProject testProject, string assemblyLocation)
{
var observer = new TestUnitTestElementObserver();
var resolver = new DefaultAssemblyResolver();
resolver.AddPath(FileSystemPath.Parse(assemblyLocation).Directory);
using (var loader = new MetadataLoader(resolver))
{
MetadataExplorer.ExploreProjects(
new Dictionary<IProject, FileSystemPath>
{
{testProject, FileSystemPath.Parse(assemblyLocation)}
},
loader, observer, CancellationToken.None);
}
return observer.Elements;
}
ModuleDefinition GetModule()
{
var location = test_case.ModuleLocation;
var directory = Path.GetDirectoryName (location);
var resolver = new DefaultAssemblyResolver ();
resolver.AddSearchDirectory (directory);
var parameters = new ReaderParameters {
SymbolReaderProvider = GetSymbolReaderProvider (),
AssemblyResolver = resolver,
};
switch (type) {
case TestCaseType.ReadImmediate:
parameters.ReadingMode = ReadingMode.Immediate;
return ModuleDefinition.ReadModule (location, parameters);
case TestCaseType.ReadDeferred:
parameters.ReadingMode = ReadingMode.Deferred;
return ModuleDefinition.ReadModule (location, parameters);
case TestCaseType.WriteFromImmediate:
parameters.ReadingMode = ReadingMode.Immediate;
return RoundTrip (location, parameters, "cecil-irt");
case TestCaseType.WriteFromDeferred:
parameters.ReadingMode = ReadingMode.Deferred;
return RoundTrip (location, parameters, "cecil-drt");
default:
return null;
}
}
IAssemblyResolver GetAssemblyResolver ()
{
if (test_case.AssemblyResolver != null)
return test_case.AssemblyResolver;
var resolver = new DefaultAssemblyResolver ();
var directory = Path.GetDirectoryName (test_case.ModuleLocation);
resolver.AddSearchDirectory (directory);
return resolver;
}
