/// <summary> /// Loads a new assembly! /// </summary> /// <param name="assembly"></param> /// <returns></returns> public async Task LoadAssembly(Assembly assembly) { var asmBytes = AssemblyUtils.GetAssemblyBinary(assembly); var asmVersion = AssemblyUtils.GetAssemblyVersion(assembly); var asmFullname = assembly.FullName; await LoadAssembly(asmFullname, asmVersion, asmBytes); }
public async Task ExecuteMethodFromAssemblyTest(int a) { var asmPath = Path.Combine(Directory.GetCurrentDirectory(), "TestAssembly.dll"); await _executiveGrain.LoadAssembly(asmPath, AssemblyUtils.GetAssemblyVersion(asmPath), asmPath); var ret = await _executiveGrain.Execute <double>(nameof(TestAssembly.TestClass), nameof(TestAssembly.TestClass.Pow2), a); Assert.AreEqual(ret, TestAssembly.TestStaticClass.Pow2(a)); }
public bool TryGetAssembly(string name, NuGetFramework targetFramework, out string path, out NuGetVersion version) { path = null; version = null; // Rewrite DNX framework names. // DNX versions match 1:1 with .NET Framework versions if (string.Equals(targetFramework.Framework, FrameworkConstants.FrameworkIdentifiers.Dnx)) { targetFramework = new NuGetFramework( FrameworkConstants.FrameworkIdentifiers.Net, targetFramework.Version); } var information = _cache.GetOrAdd(targetFramework, GetFrameworkInformation); if (information == null || !information.Exists) { Log.LogWarning($"No framework information found for {targetFramework}"); return(false); } lock (information.Assemblies) { AssemblyEntry entry; if (information.Assemblies.TryGetValue(name, out entry)) { if (string.IsNullOrEmpty(entry.Path)) { entry.Path = GetAssemblyPath(information.Path, name); } if (!string.IsNullOrEmpty(entry.Path) && entry.Version == null) { // This code path should only run on mono entry.Version = AssemblyUtils.GetAssemblyVersion(entry.Path); } path = entry.Path; version = new NuGetVersion(entry.Version); if (Log.IsEnabled(LogLevel.Verbose)) { // Trim back the path Log.LogVerbose($"Resolved {name} {version} to {path.Substring(information.Path.Length + 1)}"); } } } return(!string.IsNullOrEmpty(path)); }
private void AddPlugin(string dllPath) { // Create a new assembly from the plugin file we're adding.. Assembly pluginAssembly = Assembly.LoadFrom(dllPath); var guid = AssemblyUtils.Guid(pluginAssembly); foreach (var plugin in _repository.PluginsByType) { if (plugin.AssemblyInfo.Guid == guid) { return; // avoid loading duplicated plugin.dll file } } var machineName = Path.GetFileNameWithoutExtension(dllPath) ?? pluginAssembly.GetName().Name ?? ""; machineName = Regex.Replace(machineName, "Plugin$", "", RegexOptions.IgnoreCase); var configFileName = machineName + ".config.json"; var configFilePath = Path.Combine(_directoryLocator.PluginConfigDir, machineName, configFileName); var disabledGuids = _preferenceManager.Preferences.Plugins.DisabledPluginGuids; // Next we'll loop through all the Types found in the assembly foreach (Type pluginType in pluginAssembly.GetTypes().Where(IsValidPlugin)) { // Create a new instance and store the instance in the collection for later use // We could change this later on to not load an instance.. we have 2 options // 1- Make one instance, and use it whenever we need it.. it's always there // 2- Don't make an instance, and instead make an instance whenever we use it, then close it // For now we'll just make an instance of all the plugins var newPlugin = (IPlugin)_kernel.Get(pluginType); // TODO: Store this in preferences file newPlugin.Enabled = !disabledGuids.Contains(guid); var assemblyInfo = new PluginAssemblyInfo(dllPath, AssemblyUtils.GetAssemblyVersion(pluginAssembly), AssemblyUtils.GetLinkerTimestamp(pluginAssembly), guid, configFilePath); // Initialize the plugin newPlugin.LoadPlugin(_repository, assemblyInfo); // Add the new plugin to our collection here _repository.Add(newPlugin); } }
/// <summary> /// Loads a new assembly! /// </summary> /// <param name="targetType"></param> /// <returns></returns> public async Task LoadAssembly(Type targetType, bool loadReferences = true) { var asmVersion = AssemblyUtils.GetAssemblyVersion(targetType); var asmFullname = AssemblyUtils.GetAssemblyName(targetType); var asmBytes = AssemblyUtils.GetAssemblyBinary(targetType); await LoadAssembly(asmFullname, asmVersion, asmBytes); if (loadReferences) { var references = AssemblyUtils.GetNonSystemReferencedAssemblies(asmFullname, 0, 3); foreach (var @ref in references) { var asm = Assembly.Load(@ref); await LoadAssembly(asm); } } }
private static void ShowVersion() { Console.Error.WriteLine("{0} v{1} - compiled {2}", AssemblyUtils.GetAssemblyName(), AssemblyUtils.GetAssemblyVersion(), AssemblyUtils.GetLinkerTimestamp()); }