static void Load() { if (AppDomain.CurrentDomain.FriendlyName != "OnlineVideosSiteUtilDlls") { if (_useSeperateDomain) { _domain = AppDomain.CreateDomain("OnlineVideosSiteUtilDlls", null, null, null, true); // we need to subscribe to AssemblyResolve on the MP2 AppDomain because OnlineVideos.dll is loaded in the LoadFrom Context // and when unwrapping transparent proxy from our AppDomain, resolving types will fail because it looks only in the default Load context // we simply help .Net by returning the already loaded assembly from the LoadFrom context AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve; _pluginLoader = (PluginLoader)_domain.CreateInstanceFromAndUnwrap( Assembly.GetExecutingAssembly().Location, typeof(PluginLoader).FullName); AppDomain.CurrentDomain.AssemblyResolve -= AssemblyResolve; _domain.SetData(typeof(PluginLoader).FullName, _pluginLoader); } else { _domain = AppDomain.CurrentDomain; _pluginLoader = new PluginLoader(); } } else { _domain = AppDomain.CurrentDomain; _pluginLoader = (PluginLoader)AppDomain.CurrentDomain.GetData(typeof(PluginLoader).FullName); } }
public void ProcessAssembly(string filename) { FileInfo fileInfo = new FileInfo(filename); AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationBase = fileInfo.DirectoryName; setup.PrivateBinPath = AppDomain.CurrentDomain.BaseDirectory; setup.ApplicationName = "Loader"; setup.ShadowCopyFiles = "true"; try { appDomain = AppDomain.CreateDomain("Loading Domain", null, setup); AssemblyProcessor processor = (AssemblyProcessor) appDomain.CreateInstanceFromAndUnwrap( "TestAssembly.dll", "TestAssembly.AssemblyProcessor"); string name = fileInfo.Name.Replace(fileInfo.Extension, ""); Console.WriteLine(name); processor.Load(name); processor.Process(); } finally { if (appDomain != null) { AppDomain.Unload(appDomain); appDomain = null; } } }
public void SetUp() { string path = new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath; _localDomain = AppDomain.CreateDomain("NewDomain"); _localDomain.Load(typeof(DataAccessor).Assembly.GetName()); _localTest = (DataAccessorBuilderTest)_localDomain.CreateInstanceFromAndUnwrap(path, GetType().FullName); }
private void InitDomain(string name, AppDomainSetup setup) { #if STATIC #else _currDomain = AppDomain.CreateDomain(name, null, setup); var type = typeof(ScriptDomainContext); _context = (ScriptDomainContext)_currDomain.CreateInstanceFromAndUnwrap(type.Assembly.GetName().CodeBase, type.FullName); #endif }
public MathAssembly(string expression, string variable) { var mathAssembly = new MathFuncAssemblyCecil(); _fileName = "MathFuncLib" + "_" + GenerateRandomString(6) + ".dll"; mathAssembly.CompileFuncAndDerivative(expression, variable, "", _fileName); _domain = AppDomain.CreateDomain("MathFuncDomain"); _mathFuncObj = _domain.CreateInstanceFromAndUnwrap(_fileName, mathAssembly.NamespaceName + "." + mathAssembly.ClassName); var mathFuncObjType = _mathFuncObj.GetType(); FuncMethodInfo = mathFuncObjType.GetMethod(mathAssembly.FuncName); FuncDerivativeMethodInfo = mathFuncObjType.GetMethod(mathAssembly.FuncDerivativeName); }
RemoteSetupDomain GetDomain () { lock (this) { if (useCount++ == 0) { AppDomain.CurrentDomain.AssemblyResolve += MonoAddinsAssemblyResolve; domain = AppDomain.CreateDomain ("SetupDomain", null, AppDomain.CurrentDomain.SetupInformation); var type = typeof(RemoteSetupDomain); remoteSetupDomain = (RemoteSetupDomain) domain.CreateInstanceFromAndUnwrap (type.Assembly.Location, type.FullName); } return remoteSetupDomain; } }
public static AssemblyLoader CreateAssemblyLoader(AppDomain appDomain) { try { var assemblyLoader = appDomain.CreateInstanceFromAndUnwrap( typeof(AssemblyLoader).Assembly.CodeBase, typeof(AssemblyLoader).FullName); return assemblyLoader as AssemblyLoader; } catch (Exception ex) { Debug.WriteLine(ex); return null; } }
public AssemblyExecutor(string fileNname, string domainName) { assemblyFileName = fileNname; AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationBase = Path.GetDirectoryName(assemblyFileName); setup.PrivateBinPath = AppDomain.CurrentDomain.BaseDirectory; setup.ApplicationName = Path.GetFileName(Assembly.GetExecutingAssembly().Location); setup.ShadowCopyFiles = "true"; setup.ShadowCopyDirectories = Path.GetDirectoryName(assemblyFileName); appDomain = AppDomain.CreateDomain(domainName, null, setup); remoteExecutor = (RemoteExecutor)appDomain.CreateInstanceFromAndUnwrap(Assembly.GetExecutingAssembly().Location, typeof(RemoteExecutor).ToString()); }
public ILoader Create() { AppDomainSetup adSetup = new AppDomainSetup(); adSetup.ShadowCopyFiles = "true"; // not a boolean m_LoaderDomain = createAppDomainForLoader(adSetup); string dir = m_LoaderDomain.SetupInformation.ApplicationBase; string selfAssemblyName = (new System.Uri(Assembly.GetExecutingAssembly().CodeBase)).AbsolutePath; ILoader loader = (ILoader) m_LoaderDomain.CreateInstanceFromAndUnwrap(selfAssemblyName, "Cider_x64.Loader"); return loader; }
public ILoader Create() { AppDomainSetup adSetup = new AppDomainSetup(); adSetup.ShadowCopyFiles = "true"; // not a boolean m_LoaderDomain = createAppDomainForLoader(adSetup); string dir = m_LoaderDomain.SetupInformation.ApplicationBase; string selfAssemblyName = (new System.Uri(Assembly.GetExecutingAssembly().CodeBase)).AbsolutePath; selfAssemblyName = Uri.UnescapeDataString(selfAssemblyName); // e.g. otherwise, spaces in the path of our .EXE would be represented as '%20' ILoader loader = (ILoader) m_LoaderDomain.CreateInstanceFromAndUnwrap(selfAssemblyName, "Cider_x64.Loader"); return loader; }
private static SiloHost CreateSiloHost(AppDomain appDomain, ClusterConfiguration clusterConfig) { var args = new object[] { nameof(SiloInitializationIsRetryableTest), clusterConfig }; return (SiloHost)appDomain.CreateInstanceFromAndUnwrap( "OrleansRuntime.dll", typeof(SiloHost).FullName, false, BindingFlags.Default, null, args, CultureInfo.CurrentCulture, new object[] { }); }
private static DomainHostingStarterAgent CreateAgent(AppDomain domain) { try { return (DomainHostingStarterAgent)domain.CreateInstanceAndUnwrap( typeof(DomainHostingStarterAgent).Assembly.FullName, typeof(DomainHostingStarterAgent).FullName); } catch { return (DomainHostingStarterAgent)domain.CreateInstanceFromAndUnwrap( typeof(DomainHostingStarterAgent).Assembly.Location, typeof(DomainHostingStarterAgent).FullName); } }
// Methods ======================================================================== public void Load(string filePath) { AssemblyPath = filePath; AssemblyName = Path.GetFileName(filePath); domain = AppDomain.CreateDomain(AssemblyName); proxy = (AppDomainProxy)domain.CreateInstanceFromAndUnwrap( Assembly.GetExecutingAssembly().CodeBase, typeof(AppDomainProxy).FullName); try { proxy.LoadAssembly(filePath); } catch (Exception) { AppDomain.Unload(domain); throw; } }
public RecyclableAppDomain (string name) { var info = new AppDomainSetup () { //appbase needs to allow loading this assembly, for remoting ApplicationBase = System.IO.Path.GetDirectoryName (typeof (TemplatingAppDomainRecycler).Assembly.Location), DisallowBindingRedirects = false, DisallowCodeDownload = true, DisallowApplicationBaseProbing = false, ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, }; domain = AppDomain.CreateDomain (name, null, info); var t = typeof(DomainAssemblyLoader); AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; assemblyMap = (DomainAssemblyLoader) domain.CreateInstanceFromAndUnwrap(t.Assembly.Location, t.FullName); AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve; domain.AssemblyResolve += assemblyMap.Resolve;// new DomainAssemblyLoader(assemblyMap).Resolve; }
public EfMigrator(string assemblyPath, string qualifiedDbConfigName, string appConfigPath, string connectionString, string connectionProvider, ILogger logger) { _logger = logger; appConfigPath = Path.GetFullPath(appConfigPath); if (!File.Exists(appConfigPath)) { throw new EfMigrationException($"The {nameof(appConfigPath)} '{appConfigPath}' must exist."); } var domainSetup = AppDomain.CurrentDomain.SetupInformation; domainSetup.ConfigurationFile = appConfigPath; _logger.Debug($"Prepared AppDomain setup using {appConfigPath} as the appconfig."); var domainName = $"EfMigrator:{Guid.NewGuid()}"; _domain = AppDomain.CreateDomain(domainName, null, domainSetup); _logger.Debug($"Created new AppDomain named {domainName}."); var type = typeof(EfMigratorBackend); var fullPath = Assembly.GetAssembly(typeof(EfMigratorBackend)).Location; //var domain = AppDomain.CurrentDomain.GetAssemblies() // .Where(x => !x.IsDynamic) // .Where(x => !x.GlobalAssemblyCache) // .Select(x => Path.GetDirectoryName(x.Location)) // .Distinct(); //var domains = string.Join(", ", domain); //logger.Debug($"Loading assemblies into appDomain: {domains}."); Debug.Assert(fullPath != null, "fullPath != null"); var migrator = (EfMigratorBackend) _domain.CreateInstanceFromAndUnwrap(fullPath, type.FullName); _logger.Debug("Created new instance."); migrator.Initialize(assemblyPath, qualifiedDbConfigName, connectionString, connectionProvider); _logger.Debug($"Initialized new {nameof(EfMigratorBackend)} within {domainName}."); CurrentMigration = migrator.GetCurrentMigration() ?? InitialDatabase; var currentMigrationStr = CurrentMigration == InitialDatabase ? "$InitialDatabase" : CurrentMigration; _logger.Information($"Current Migration is {currentMigrationStr}."); _migratorBackend = migrator; }
public static RemoteLoader CreateInstance(AppDomain remoteDomain, string csUnitRoot) { try { remoteDomain.SetData("csUnitRoot", csUnitRoot); var remoteLoader = (RemoteLoader) remoteDomain.CreateInstanceFromAndUnwrap( Path.Combine(csUnitRoot, "csUnit.Core.dll"), typeof(RemoteLoader).FullName); return remoteLoader; } catch (Exception ex) { Debug.WriteLine(string.Format("## Listing assemblies in domain '{0}'##", remoteDomain.FriendlyName)); foreach (var assembly in remoteDomain.GetAssemblies()) { Debug.WriteLine(assembly.FullName); } Debug.WriteLine("## end of list ##"); Debug.WriteLine("Could not instantiate remote loader. " + ex); return null; } }
private void Initialize() { if (_info.GeneratorFolder == null) { throw new InvalidOperationException( "The RemoteAppDomainTestGeneratorFactory has to be configured with the Setup() method before initialization."); } var appDomainSetup = new AppDomainSetup { ShadowCopyFiles = "true", }; _appDomain = System.AppDomain.CreateDomain("AppDomainForTestGeneration", null, appDomainSetup); var testGeneratorFactoryTypeFullName = typeof(TestGeneratorFactory).FullName; Debug.Assert(testGeneratorFactoryTypeFullName != null); _tracer.Trace(string.Format("TestGeneratorFactory: {0}", testGeneratorFactoryTypeFullName), LogCategory); _tracer.Trace("AssemblyResolve Event added", LogCategory); System.AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve; var remoteAppDomainAssembly = _remoteAppDomainResolverType.Assembly; _remoteAppDomainResolver = (RemoteAppDomainResolver)_appDomain.CreateInstanceFromAndUnwrap(remoteAppDomainAssembly.Location, _remoteAppDomainResolverType.FullName, true, BindingFlags.Default, null, null, null, null); _remoteAppDomainResolver.Init(_info.GeneratorFolder); var generatorFactoryObject = _appDomain.CreateInstanceAndUnwrap(_info.RemoteGeneratorAssemblyName, testGeneratorFactoryTypeFullName); _remoteTestGeneratorFactory = generatorFactoryObject as ITestGeneratorFactory; if (_remoteTestGeneratorFactory == null) { throw new InvalidOperationException("Could not load test generator factory."); } _usageCounter = new UsageCounter(LoseReferences); _tracer.Trace("AppDomain for generator created", LogCategory); }
private void RunApplication(string action) { if (watcher == null) { watcher = new FileSystemWatcher(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); watcher.Changed += delegate(object sender, FileSystemEventArgs e) { StopRunner(string.Format(System.Globalization.CultureInfo.CurrentCulture,"One or more DLLs have changed - waiting {0}s", restartTime)); waitTimer.Stop(); waitTimer.Start(); }; watcher.EnableRaisingEvents = true; watcher.NotifyFilter = NotifyFilters.CreationTime | NotifyFilters.LastWrite | NotifyFilters.Size; } // Allow the user to turn shadow-copying off var setting = ConfigurationManager.AppSettings["ShadowCopy"] ?? string.Empty; var useShadowCopying = !(string.Equals(setting, "off", StringComparison.OrdinalIgnoreCase) || string.Equals(setting, "false", StringComparison.OrdinalIgnoreCase)); try { this.runnerDomain = CreateNewDomain(useShadowCopying); } catch (FileLoadException) { // Unable to use shadow-copying (no user profile?), therefore turn off shadow-copying useShadowCopying = false; this.runnerDomain = CreateNewDomain(useShadowCopying); } runner = runnerDomain.CreateInstanceFromAndUnwrap(Assembly.GetExecutingAssembly().Location, typeof(AppRunner).FullName) as AppRunner; try { runner.Run(action, useShadowCopying); } catch (SerializationException) { var configFilename = ConfigurationManager.AppSettings["ccnet.config"]; configFilename = string.IsNullOrEmpty(configFilename) ? Path.Combine(Environment.CurrentDirectory, "ccnet.log") : configFilename; throw new ApplicationException( string.Format(System.Globalization.CultureInfo.CurrentCulture,"A fatal error has occurred while starting CCService. Please check '{0}' for any details.", configFilename)); } }
private void Create(bool recreate = false) { if (domain == null || recreate) { if (domain != null) { frm.Hide(); AppDomain.Unload(domain); domain = null; } var myLocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var info = new AppDomainSetup { ShadowCopyFiles = "true" }; domain = AppDomain.CreateDomain("TranscodingDomain", null, info); frm = (RemoteImageViewer)domain.CreateInstanceFromAndUnwrap(typeof(RemoteImageViewer).Assembly.Location, typeof(RemoteImageViewer).FullName); frm.InitPlugin(pluginPath); } frm.SetFramesPerSecond(framesPerSecond); frm.SetOnError(onError); if(sessionDataPath != null) frm.SetSessionDataPath(sessionDataPath); if( backgroundImage != null) frm.SetBackgroundImage(backgroundImage); frm.ClientSize = clientSize; frm.SetPosition(left, top); frm.SetPlaybackSpeed(playbackSpeed); frm.SetOnAnimationTick(onAnimationTick); frm.SetDrawAction(drawAction); frm.SetPaused(isPaused); frm.Refresh(); }
public SystemReflectionProvider(string assembly) { try { var domainSetup = new AppDomainSetup { ApplicationBase = Path.GetDirectoryName(assembly), ApplicationName = AppDomain.CurrentDomain.SetupInformation.ApplicationName, LoaderOptimization = LoaderOptimization.MultiDomainHost }; _childDomain = AppDomain.CreateDomain("Type locator app domain", null, domainSetup); // Create an instance of the runtime in the second AppDomain. // A proxy to the object is returned. _locator = (ISystemReflectionProvider_Internal)_childDomain.CreateInstanceFromAndUnwrap(Assembly.GetExecutingAssembly().Location, typeof(SystemReflectionProvider_Internal).FullName); _locator.Load(assembly); } catch (Exception ex) { Logging.Logger.Write(ex); } }
/// <summary> /// Creates a remote instance of a type within another AppDomain. /// </summary> /// <remarks> /// This method first uses <see cref="AppDomain.CreateInstanceAndUnwrap(string, string)" /> to /// try create an instance of the type. If that fails, it uses <see cref="AppDomain.CreateInstanceFromAndUnwrap(string, string)" /> /// to load the assembly that contains the type into the AppDomain then create an instance of the type. /// </remarks> /// <param name="appDomain">The AppDomain in which to create the instance.</param> /// <param name="type">The type to instantiate.</param> /// <param name="args">The constructor arguments for the type.</param> /// <returns>The remote instance.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="appDomain"/> or <paramref name="type"/> /// is null.</exception> public static object CreateRemoteInstance(AppDomain appDomain, Type type, params object[] args) { if (appDomain == null) throw new ArgumentNullException("appDomain"); // FIX #pragma warning disable 618 Assembly assembly = type.Assembly; try { return appDomain.CreateInstanceAndUnwrap(assembly.FullName, type.FullName, false, BindingFlags.Default, null, args, null, null, null); } catch (Exception) { string assemblyFile = AssemblyUtils.GetFriendlyAssemblyLocation(type.Assembly); return appDomain.CreateInstanceFromAndUnwrap(assemblyFile, type.FullName, false, BindingFlags.Default, null, args, null, null, null); } #pragma warning restore 618 }
void DetectResharperLoading(AppDomain vsAppDomain) { while (_retries <= MAX_RETRIES) { Assembly resharperAssembly; try { resharperAssembly = vsAppDomain.Load("JetBrains.Platform.ReSharper.Shell"); } catch { resharperAssembly = null; } if (resharperAssembly == null && _retries++ <= MAX_RETRIES) { _output.Write("ReSharper not found, try {0}/{1}, sleeping for 2 seconds.", _retries, MAX_RETRIES); Thread.Sleep(TimeSpan.FromSeconds(2)); continue; } var resharperVersion = resharperAssembly.GetName().Version; var pluginManagerType = LoadTypeFromVersion(resharperVersion); if (pluginManagerType == null) return; var assemblyLocation = pluginManagerType.Assembly.Location; var destinationAssemblyFile = CopyAndSign(assemblyLocation); _pluginManager = vsAppDomain.CreateInstanceFromAndUnwrap(destinationAssemblyFile.Path, pluginManagerType.FullName); return; } }
public static ScriptDomain Load(string path) { int num; List <string> list; List <string> list2; path = Path.GetFullPath(path); AppDomainSetup info = new AppDomainSetup { ApplicationBase = path, ShadowCopyFiles = "true", ShadowCopyDirectories = path }; StrongName[] fullTrustAssemblies = new StrongName[0]; System.AppDomain domain = System.AppDomain.CreateDomain("ScriptDomain_" + (path.GetHashCode() * Environment.TickCount).ToString("X"), null, info, new PermissionSet(PermissionState.Unrestricted), fullTrustAssemblies); domain.InitializeLifetimeService(); ScriptDomain domain2 = null; try { domain2 = (ScriptDomain)domain.CreateInstanceFromAndUnwrap(typeof(ScriptDomain).Assembly.Location, typeof(ScriptDomain).FullName); } catch (Exception exception1) { string[] strArray2 = new string[] { "Failed to create script domain '", domain.FriendlyName, "':", Environment.NewLine, exception1.ToString() }; GTA.Log("[ERROR]", strArray2); System.AppDomain.Unload(domain); return(null); } string[] message = new string[] { "Loading scripts from '", path, "' into script domain '", domain.FriendlyName, "' ..." }; GTA.Log("[INFO]", message); if (!Directory.Exists(path)) { string[] strArray7 = new string[] { "Failed to reload scripts because the directory is missing." }; GTA.Log("[ERROR]", strArray7); return(domain2); } else { list2 = new List <string>(); list = new List <string>(); try { list2.AddRange(Directory.GetFiles(path, "*.vb", SearchOption.AllDirectories)); list2.AddRange(Directory.GetFiles(path, "*.cs", SearchOption.AllDirectories)); list.AddRange(Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories)); } catch (Exception exception5) { string[] strArray6 = new string[] { "Failed to reload scripts:", Environment.NewLine, exception5.ToString() }; GTA.Log("[ERROR]", strArray6); System.AppDomain.Unload(domain); return(null); } num = 0; } while (true) { if (num >= list.Count) { List <string> .Enumerator enumerator2 = list2.GetEnumerator(); if (enumerator2.MoveNext()) { do { string current = enumerator2.Current; domain2.LoadScript(current); }while (enumerator2.MoveNext()); } List <string> .Enumerator enumerator = list.GetEnumerator(); if (enumerator.MoveNext()) { do { string current = enumerator.Current; domain2.LoadAssembly(current); }while (enumerator.MoveNext()); } break; } try { string assemblyFile = list[num]; if (AssemblyName.GetAssemblyName(assemblyFile).Name == "ScriptHookVDotNet") { string[] strArray5 = new string[] { "Removing assembly file '", Path.GetFileName(assemblyFile), "'." }; GTA.Log("[WARNING]", strArray5); num += -1; list.RemoveAt(num); try { File.Delete(assemblyFile); } catch (Exception exception6) { string[] strArray4 = new string[] { "Failed to delete assembly file:", Environment.NewLine, exception6.ToString() }; GTA.Log("[ERROR]", strArray4); } } } catch (BadImageFormatException) { } catch (Exception exception7) { string[] strArray3 = new string[] { "Failed to load assembly ", list[num], Environment.NewLine, exception7.ToString() }; GTA.Log("[ERROR]", strArray3); } num++; } return(domain2); }
private static Silo LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, out AppDomain appDomain) { AppDomainSetup setup = GetAppDomainSetupInfo(); appDomain = AppDomain.CreateDomain(siloName, null, setup); // Load each of the additional assemblies. Silo.TestHookups.CodeGeneratorOptimizer optimizer = null; foreach (var assembly in additionalAssemblies) { if (optimizer == null) { optimizer = (Silo.TestHookups.CodeGeneratorOptimizer) appDomain.CreateInstanceFromAndUnwrap( "OrleansRuntime.dll", typeof(Silo.TestHookups.CodeGeneratorOptimizer).FullName, false, BindingFlags.Default, null, null, CultureInfo.CurrentCulture, new object[] { }); } if (assembly.Value != null) { optimizer.AddCachedAssembly(assembly.Key, assembly.Value); } } var args = new object[] { siloName, type, config }; var silo = (Silo)appDomain.CreateInstanceFromAndUnwrap( "OrleansRuntime.dll", typeof(Silo).FullName, false, BindingFlags.Default, null, args, CultureInfo.CurrentCulture, new object[] { }); appDomain.UnhandledException += ReportUnobservedException; return silo; }
/// <summary> /// Add new device profile. /// </summary> /// <param name="request"></param> /// <returns></returns> public GXDeviceProfilesUpdateResponse Post(GXDeviceProfilesUpdateRequest request) { List <GXEventsItem> events = new List <GXEventsItem>(); GXAmiDeviceProfile DeviceProfiles = null; lock (Db) { using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted)) { string filename = Path.GetTempFileName(); using (FileStream stream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None)) { BinaryWriter w = new BinaryWriter(stream); w.Write(request.Data); } string pathToDll = this.GetType().Assembly.CodeBase; // Create an Application Domain: AppDomainSetup domainSetup = new AppDomainSetup { PrivateBinPath = pathToDll }; System.AppDomain td = null; string dir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.DirectorySeparatorChar); //Try to load device template and unload assmbly. try { td = AppDomain.CreateDomain("TestDomain", null, domainSetup); GXProxyClass pc = (GXProxyClass)(td.CreateInstanceFromAndUnwrap(pathToDll, typeof(GXProxyClass).FullName)); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } byte[] data; string addInType, assemblyName; List <object[]> items = pc.Import(filename, dir, out data, out assemblyName, out addInType); ulong DeviceProfileID = 0; ulong categoryTemplateID = 0; ulong propertyTemplateID = 0; ulong tableTemplateID = 0; int version = 0; foreach (object[] it in items) { if (it[1] is GXAmiDeviceProfile) { DeviceProfiles = it[1] as GXAmiDeviceProfile; events.Add(new GXEventsItem(ActionTargets.DeviceProfile, Actions.Add, DeviceProfiles)); //Find new version number for the template. foreach (GXAmiDeviceProfile dt in Db.Select <GXAmiDeviceProfile>(q => q.Guid == DeviceProfiles.Guid)) { if (dt.ProfileVersion > version) { version = dt.ProfileVersion; } } ++version; DeviceProfiles.ProtocolAddInType = addInType; DeviceProfiles.ProtocolAssembly = assemblyName; DeviceProfiles.ProfileVersion = version; } else if (it[1] is GXAmiCategoryTemplate) { tableTemplateID = 0; (it[1] as GXAmiCategoryTemplate).DeviceID = DeviceProfileID; (it[1] as GXAmiCategoryTemplate).Id += DeviceProfileID << 16; (it[1] as GXAmiCategoryTemplate).TemplateVersion = version; } else if (it[1] is GXAmiDataTableTemplate) { categoryTemplateID = 0; (it[1] as GXAmiDataTableTemplate).DeviceID = DeviceProfileID; (it[1] as GXAmiDataTableTemplate).Id += DeviceProfileID << 16; (it[1] as GXAmiDataTableTemplate).TemplateVersion = version; } else if (it[1] is GXAmiPropertyTemplate) { (it[1] as GXAmiPropertyTemplate).DeviceID = DeviceProfileID; (it[1] as GXAmiPropertyTemplate).TemplateVersion = version; if (categoryTemplateID != 0) { (it[1] as GXAmiPropertyTemplate).ParentID = categoryTemplateID; } else if (tableTemplateID != 0) { (it[1] as GXAmiPropertyTemplate).ParentID = tableTemplateID; } else { throw new ArgumentOutOfRangeException("Parent ID."); } (it[1] as GXAmiPropertyTemplate).Id += DeviceProfileID << 16; } else if (it[1] is GXAmiParameterTemplate) { (it[1] as GXAmiParameterTemplate).DeviceID = DeviceProfileID; (it[1] as GXAmiParameterTemplate).TemplateVersion = version; if (it[0] is GXAmiDeviceProfile) { (it[1] as GXAmiParameterTemplate).ParentID = DeviceProfileID << 16; } else if (it[0] is GXAmiCategoryTemplate) { (it[1] as GXAmiParameterTemplate).ParentID = categoryTemplateID; } else if (it[0] is GXAmiDataTableTemplate) { (it[1] as GXAmiParameterTemplate).ParentID = tableTemplateID; } else if (it[0] is GXAmiPropertyTemplate) { (it[1] as GXAmiParameterTemplate).ParentID = propertyTemplateID; } } Db.Insert(it[1]); if (it[1] is GXAmiDeviceProfile) { #if !SS4 ulong value = (ulong)Db.GetLastInsertId(); #else ulong value = (ulong)Db.LastInsertId(); #endif (it[1] as GXAmiDeviceProfile).Id = value; DeviceProfileID = value; //Update allowed media types. foreach (GXAmiMediaType mt in (it[1] as GXAmiDeviceProfile).AllowedMediaTypes) { mt.DeviceProfileId = DeviceProfileID; Db.Insert(mt); } } else if (it[1] is GXAmiCategoryTemplate) { categoryTemplateID = (it[1] as GXAmiCategoryTemplate).Id; } else if (it[1] is GXAmiDataTableTemplate) { tableTemplateID = (it[1] as GXAmiDataTableTemplate).Id; } else if (it[1] is GXAmiPropertyTemplate) { propertyTemplateID = (it[1] as GXAmiPropertyTemplate).Id; if ((it[1] as GXAmiPropertyTemplate).Values != null && (it[1] as GXAmiPropertyTemplate).Values.Length != 0) { #if !SS4 ulong value = (ulong)Db.GetLastInsertId(); #else ulong value = (ulong)Db.LastInsertId(); #endif foreach (GXAmiValueItem vi in (it[1] as GXAmiPropertyTemplate).Values) { vi.ProfileId = DeviceProfileID; vi.PropertyId = value; Db.Insert(vi); } } } else if (it[1] is GXAmiParameterTemplate) { if ((it[1] as GXAmiParameterTemplate).Values != null && (it[1] as GXAmiParameterTemplate).Values.Length != 0) { #if !SS4 ulong value = (ulong)Db.GetLastInsertId(); #else ulong value = (ulong)Db.LastInsertId(); #endif foreach (GXAmiValueItem vi in (it[1] as GXAmiParameterTemplate).Values) { vi.ProfileId = DeviceProfileID; vi.ParameterId = value; Db.Insert(vi); } } } } //Save device template to data blocks. foreach (GXAmiDeviceProfilesDataBlock it in SplitDataToPackets(DeviceProfileID, filename)) { Db.Insert(it); } foreach (GXAmiDeviceProfilesDataBlock it in SplitDataToPackets(DeviceProfileID, filename)) { Db.Insert(it); } if (request.UserGroups != null) { foreach (long ugId in request.UserGroups) { GXAmiUserGroupDeviceProfile it = new GXAmiUserGroupDeviceProfile(); it.DeviceProfileID = DeviceProfileID; it.UserGroupID = ugId; Db.Insert(it); } } } finally { // Unload the application domain: if (td != null) { System.AppDomain.Unload(td); } if (dir != null) { try { Directory.Delete(dir, true); } catch { //It's OK if this fails. } } } trans.Commit(); } } AppHost host = this.ResolveService <AppHost>(); host.SetEvents(Db, this.Request, 0, events); return(new GXDeviceProfilesUpdateResponse(request.UserGroups, DeviceProfiles)); }
public static BamlDecompiler CreateBamlDecompilerInAppDomain(ref AppDomain appDomain, string assemblyFileName) { if (appDomain == null) { // Construct and initialize settings for a second AppDomain. AppDomainSetup bamlDecompilerAppDomainSetup = new AppDomainSetup(); bamlDecompilerAppDomainSetup.ApplicationBase = "file:///" + Path.GetDirectoryName(assemblyFileName); bamlDecompilerAppDomainSetup.DisallowBindingRedirects = false; bamlDecompilerAppDomainSetup.DisallowCodeDownload = true; bamlDecompilerAppDomainSetup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; // Create the second AppDomain. appDomain = AppDomain.CreateDomain("BamlDecompiler AD", null, bamlDecompilerAppDomainSetup); } return (BamlDecompiler)appDomain.CreateInstanceFromAndUnwrap(typeof(BamlDecompiler).Assembly.Location, typeof(BamlDecompiler).FullName); }
/// <summary> /// Gets the current proxy. /// </summary> /// <returns>ParadoxCommandsProxy.</returns> public static ParadoxCommandsProxy CreateProxy(AppDomain domain) { if (domain == null) throw new ArgumentNullException("domain"); return (ParadoxCommandsProxy)domain.CreateInstanceFromAndUnwrap(typeof(ParadoxCommandsProxy).Assembly.Location, typeof(ParadoxCommandsProxy).FullName); }
private static void InstallerStageTwo(AppDomain appDomain) { if( Cancelling ) { return; } // stage two: close our bootstrap GUI, and start the Installer in the new AppDomain, // of course, this has all got to happen on the original thread. *sigh* Logger.Message("Got to Installer Stage Two"); #if DEBUG var localAssembly = AcquireFile("CoApp.Toolkit.Engine.Client.dll"); Logger.Message("Local Assembly: " + localAssembly); if (!string.IsNullOrEmpty(localAssembly)) { // use the one found locally. appDomain.CreateInstanceFromAndUnwrap(localAssembly, "CoApp.Toolkit.Engine.Client.Installer", false, BindingFlags.Default, null, new[] { MsiFilename }, null, null); // if it didn't throw here, we can assume that the CoApp service is running, and we can get to our assembly. Logger.Warning("Done! Exiting (debug)"); ExitQuick(); } #endif // meh. use strong named assembly appDomain.CreateInstanceAndUnwrap( "CoApp.Toolkit.Engine.Client, Version=1.0.0.0, Culture=neutral, PublicKeyToken=820d50196d4e8857", "CoApp.Toolkit.Engine.Client.Installer", false, BindingFlags.Default, null, new[] { MsiFilename }, null, null); // since we've done everything we need to do, we're out of here. Right Now. Logger.Warning("Done! Exiting"); ExitQuick(); }
private void CompileAndExecute(string[] files, string[] args, IScriptManagerCallback callback, string[] filesToEmbed) { try { // Create an AppDomain to compile and execute the code // This enables us to cancel the execution if needed executionDomain = AppDomain.CreateDomain("ExecutionDomain"); var manager = (IScriptManager)executionDomain.CreateInstanceFromAndUnwrap(typeof(BaseApp).Assembly.Location, typeof(ScriptManager).FullName); manager.CompileAndExecuteFile(files, args, this, filesToEmbed); } catch(UnsupportedLanguageExecption e) { ShowErrorMessageFromResource("UnsupportedLanguage", e.Extension); } catch(AppDomainUnloadedException e) { System.Diagnostics.Trace.WriteLine(e.Message); } catch(Exception e) { ShowErrorMessage(e.Message); } TerminateExecutionLoop(); }
private static Silo LoadSiloInNewAppDomain(string siloName, Silo.SiloType type, ClusterConfiguration config, out AppDomain appDomain) { AppDomainSetup setup = GetAppDomainSetupInfo(); appDomain = AppDomain.CreateDomain(siloName, null, setup); var args = new object[] { siloName, type, config }; var silo = (Silo)appDomain.CreateInstanceFromAndUnwrap( "OrleansRuntime.dll", typeof(Silo).FullName, false, BindingFlags.Default, null, args, CultureInfo.CurrentCulture, new object[] { }); appDomain.UnhandledException += ReportUnobservedException; return silo; }
internal List<Job.Base.Job> FindJobsIn(AppDomain appDom) { var jobs = new List<Job.Base.Job>(); var loader = GetLoader(appDom); var jobTypes = loader.GetJobTypes(); foreach (var jobType in jobTypes) { var job = appDom.CreateInstanceFromAndUnwrap(jobType.Item1, jobType.Item2) as Job.Base.Job; if (job != null) { jobs.Add(job); } } return jobs; }
private AssemblyLoader GetLoader(AppDomain appDomain) { return appDomain.CreateInstanceFromAndUnwrap( Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Scurry.Executor.Loader.dll"), "Scurry.Executor.Loader.AssemblyLoader") as AssemblyLoader; }
private void Resolve(AppDomain appDomain) { appDomain.CreateInstanceFromAndUnwrap( Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Scurry.Executor.Loader.dll"), "Scurry.Executor.Loader.Resolver", false, 0, null, new object[] { AppDomain.CurrentDomain.BaseDirectory, new string[] { AppDomain.CurrentDomain.BaseDirectory } }, null, null); }