TypeLoader.cs 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. using System.Reflection;
  6. using System.Text;
  7. using BepInEx.Configuration;
  8. using BepInEx.Logging;
  9. using Mono.Cecil;
  10. namespace BepInEx.Bootstrap
  11. {
  12. /// <summary>
  13. /// A cacheable metadata item. Can be used with <see cref="TypeLoader.LoadAssemblyCache{T}"/> and <see cref="TypeLoader.SaveAssemblyCache{T}"/> to cache plugin metadata.
  14. /// </summary>
  15. public interface ICacheable
  16. {
  17. /// <summary>
  18. /// Serialize the object into a binary format.
  19. /// </summary>
  20. /// <param name="bw"></param>
  21. void Save(BinaryWriter bw);
  22. /// <summary>
  23. /// Loads the object from binary format.
  24. /// </summary>
  25. /// <param name="br"></param>
  26. void Load(BinaryReader br);
  27. }
  28. /// <summary>
  29. /// A cached assembly.
  30. /// </summary>
  31. /// <typeparam name="T"></typeparam>
  32. public class CachedAssembly<T> where T : ICacheable
  33. {
  34. /// <summary>
  35. /// List of cached items inside the assembly.
  36. /// </summary>
  37. public List<T> CacheItems { get; set; }
  38. /// <summary>
  39. /// Timestamp of the assembly. Used to check the age of the cache.
  40. /// </summary>
  41. public long Timestamp { get; set; }
  42. }
  43. /// <summary>
  44. /// Provides methods for loading specified types from an assembly.
  45. /// </summary>
  46. public static class TypeLoader
  47. {
  48. private static readonly DefaultAssemblyResolver resolver;
  49. private static readonly ReaderParameters readerParameters;
  50. static TypeLoader()
  51. {
  52. resolver = new DefaultAssemblyResolver();
  53. readerParameters = new ReaderParameters { AssemblyResolver = resolver };
  54. resolver.ResolveFailure += (sender, reference) =>
  55. {
  56. var name = new AssemblyName(reference.FullName);
  57. if (Utility.TryResolveDllAssembly(name, Paths.BepInExAssemblyDirectory, readerParameters, out var assembly) ||
  58. Utility.TryResolveDllAssembly(name, Paths.PluginPath, readerParameters, out assembly) ||
  59. Utility.TryResolveDllAssembly(name, Paths.ManagedPath, readerParameters, out assembly))
  60. return assembly;
  61. return AssemblyResolve?.Invoke(sender, reference);
  62. };
  63. }
  64. public static event AssemblyResolveEventHandler AssemblyResolve;
  65. /// <summary>
  66. /// Looks up assemblies in the given directory and locates all types that can be loaded and collects their metadata.
  67. /// </summary>
  68. /// <typeparam name="T">The specific base type to search for.</typeparam>
  69. /// <param name="directory">The directory to search for assemblies.</param>
  70. /// <param name="typeSelector">A function to check if a type should be selected and to build the type metadata.</param>
  71. /// <param name="assemblyFilter">A filter function to quickly determine if the assembly can be loaded.</param>
  72. /// <param name="cacheName">The name of the cache to get cached types from.</param>
  73. /// <returns>A list of all loadable type metadatas indexed by the full path to the assembly that contains the types.</returns>
  74. public static Dictionary<string, List<T>> FindPluginTypes<T>(string directory, Func<TypeDefinition, T> typeSelector, Func<AssemblyDefinition, bool> assemblyFilter = null, string cacheName = null) where T : ICacheable, new()
  75. {
  76. var result = new Dictionary<string, List<T>>();
  77. Dictionary<string, CachedAssembly<T>> cache = null;
  78. if (cacheName != null)
  79. cache = LoadAssemblyCache<T>(cacheName);
  80. foreach (string dll in Directory.GetFiles(Path.GetFullPath(directory), "*.dll", SearchOption.AllDirectories))
  81. try
  82. {
  83. if (cache != null && cache.TryGetValue(dll, out var cacheEntry))
  84. {
  85. long lastWrite = File.GetLastWriteTimeUtc(dll).Ticks;
  86. if (lastWrite == cacheEntry.Timestamp)
  87. {
  88. result[dll] = cacheEntry.CacheItems;
  89. continue;
  90. }
  91. }
  92. var ass = AssemblyDefinition.ReadAssembly(dll, readerParameters);
  93. if (!assemblyFilter?.Invoke(ass) ?? false)
  94. {
  95. ass.Dispose();
  96. continue;
  97. }
  98. var matches = ass.MainModule.Types.Select(typeSelector).Where(t => t != null).ToList();
  99. if (matches.Count == 0)
  100. {
  101. ass.Dispose();
  102. continue;
  103. }
  104. result[dll] = matches;
  105. ass.Dispose();
  106. }
  107. catch (Exception e)
  108. {
  109. Logger.LogError(e.ToString());
  110. }
  111. if (cacheName != null)
  112. SaveAssemblyCache(cacheName, result);
  113. return result;
  114. }
  115. /// <summary>
  116. /// Loads an index of type metadatas from a cache.
  117. /// </summary>
  118. /// <param name="cacheName">Name of the cache</param>
  119. /// <typeparam name="T">Cacheable item</typeparam>
  120. /// <returns>Cached type metadatas indexed by the path of the assembly that defines the type. If no cache is defined, return null.</returns>
  121. public static Dictionary<string, CachedAssembly<T>> LoadAssemblyCache<T>(string cacheName) where T : ICacheable, new()
  122. {
  123. if (!EnableAssemblyCache.Value)
  124. return null;
  125. var result = new Dictionary<string, CachedAssembly<T>>();
  126. try
  127. {
  128. string path = Path.Combine(Paths.CachePath, $"{cacheName}_typeloader.dat");
  129. if (!File.Exists(path))
  130. return null;
  131. using (var br = new BinaryReader(File.OpenRead(path)))
  132. {
  133. int entriesCount = br.ReadInt32();
  134. for (var i = 0; i < entriesCount; i++)
  135. {
  136. string entryIdentifier = br.ReadString();
  137. long entryDate = br.ReadInt64();
  138. int itemsCount = br.ReadInt32();
  139. var items = new List<T>();
  140. for (var j = 0; j < itemsCount; j++)
  141. {
  142. var entry = new T();
  143. entry.Load(br);
  144. items.Add(entry);
  145. }
  146. result[entryIdentifier] = new CachedAssembly<T> { Timestamp = entryDate, CacheItems = items };
  147. }
  148. }
  149. }
  150. catch (Exception e)
  151. {
  152. Logger.LogWarning($"Failed to load cache \"{cacheName}\"; skipping loading cache. Reason: {e.Message}.");
  153. }
  154. return result;
  155. }
  156. /// <summary>
  157. /// Saves indexed type metadata into a cache.
  158. /// </summary>
  159. /// <param name="cacheName">Name of the cache</param>
  160. /// <param name="entries">List of plugin metadatas indexed by the path to the assembly that contains the types</param>
  161. /// <typeparam name="T">Cacheable item</typeparam>
  162. public static void SaveAssemblyCache<T>(string cacheName, Dictionary<string, List<T>> entries) where T : ICacheable
  163. {
  164. if (!EnableAssemblyCache.Value)
  165. return;
  166. try
  167. {
  168. if (!Directory.Exists(Paths.CachePath))
  169. Directory.CreateDirectory(Paths.CachePath);
  170. string path = Path.Combine(Paths.CachePath, $"{cacheName}_typeloader.dat");
  171. using (var bw = new BinaryWriter(File.OpenWrite(path)))
  172. {
  173. bw.Write(entries.Count);
  174. foreach (var kv in entries)
  175. {
  176. bw.Write(kv.Key);
  177. bw.Write(File.GetLastWriteTimeUtc(kv.Key).Ticks);
  178. bw.Write(kv.Value.Count);
  179. foreach (var item in kv.Value)
  180. item.Save(bw);
  181. }
  182. }
  183. }
  184. catch (Exception e)
  185. {
  186. Logger.LogWarning($"Failed to save cache \"{cacheName}\"; skipping saving cache. Reason: {e.Message}.");
  187. }
  188. }
  189. /// <summary>
  190. /// Converts TypeLoadException to a readable string.
  191. /// </summary>
  192. /// <param name="ex">TypeLoadException</param>
  193. /// <returns>Readable representation of the exception</returns>
  194. public static string TypeLoadExceptionToString(ReflectionTypeLoadException ex)
  195. {
  196. var sb = new StringBuilder();
  197. foreach (var exSub in ex.LoaderExceptions)
  198. {
  199. sb.AppendLine(exSub.Message);
  200. if (exSub is FileNotFoundException exFileNotFound)
  201. {
  202. if (!string.IsNullOrEmpty(exFileNotFound.FusionLog))
  203. {
  204. sb.AppendLine("Fusion Log:");
  205. sb.AppendLine(exFileNotFound.FusionLog);
  206. }
  207. }
  208. else if (exSub is FileLoadException exLoad)
  209. {
  210. if (!string.IsNullOrEmpty(exLoad.FusionLog))
  211. {
  212. sb.AppendLine("Fusion Log:");
  213. sb.AppendLine(exLoad.FusionLog);
  214. }
  215. }
  216. sb.AppendLine();
  217. }
  218. return sb.ToString();
  219. }
  220. #region Config
  221. private static ConfigWrapper<bool> EnableAssemblyCache = ConfigFile.CoreConfig.Wrap(
  222. "Caching",
  223. "EnableAssemblyCache",
  224. "Enable/disable assembly metadata cache\nEnabling this will speed up discovery of plugins and patchers by caching the metadata of all types BepInEx discovers.",
  225. true);
  226. #endregion
  227. }
  228. }