public InterfaceAppDomainProxy(Type appDomainSetupType, bool appDomainSetupTypeLoadFromMainModule = false) { AppDomain.MonitoringIsEnabled = true; AppDomainSetupType = appDomainSetupType; PermissionSet grantSet = new PermissionSet(PermissionState.Unrestricted); AppDomain appDomain = AppDomain.CreateDomain("Interface", null, new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase }, grantSet); string assemblyFile = System.Diagnostics.Process.GetCurrentProcess()?.MainModule?.FileName; if (null != appDomainSetupType) { if (appDomainSetupTypeLoadFromMainModule && !IsRunningInHostingProcess) { appDomain.CreateInstanceFrom(assemblyFile, appDomainSetupType.FullName); } else { appDomain.CreateInstance(appDomainSetupType.Assembly.FullName, appDomainSetupType.FullName); } } Type typeFromHandle = typeof(AppDomainProxyByte); InterfaceAppDomainSetup.Setup(); Proxy = (AppDomainProxyByte)appDomain.CreateInstanceAndUnwrap(typeFromHandle.Assembly.FullName, typeFromHandle.FullName); InterfaceAppDomain = appDomain; }
public static void Init() { // Try restarting in another AppDomain if possible. try { // Give the new AppDomain full permissions. PermissionSet permissionSet = new PermissionSet(PermissionState.Unrestricted); permissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.AllFlags)); // The ApplicationBase of the new domain should be the directory containing the current DLL. AppDomainSetup appDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(typeof(InitProxy).Assembly.Location) }; _childDomain = AppDomain.CreateDomain("SonicGlvl", null, appDomainSetup, permissionSet); _childDomain.UnhandledException += ChildDomain_UnhandledException; // Now make the new AppDomain load our code using our proxy. Type proxyType = typeof(InitProxy); _proxyObject = _childDomain.CreateInstanceFrom(proxyType.Assembly.Location, proxyType.FullName).Unwrap(); // Our AssemblyResolve will pick the missing DLL out. _proxyObject.Run(); } catch (Exception ex) { Console.WriteLine(ex); Initialize(); } }
/// <span class="code-SummaryComment"><summary></span> /// Loads an assembly into a new AppDomain and obtains all the /// namespaces in the loaded Assembly, which are returned as a /// List. The new AppDomain is then Unloaded /// <span class="code-SummaryComment"></summary></span> /// <span class="code-SummaryComment"><param name="assemblyLocation">The Assembly file </span> /// location<span class="code-SummaryComment"></param></span> /// <span class="code-SummaryComment"><returns>A list of found namespaces</returns></span> public List <String> GetNamespaces(FileInfo assemblyLocation) { List <String> namespaces = new List <String>(); //if (string.IsNullOrEmpty(assemblyLocation.Directory.FullName)) //{ // throw new InvalidOperationException("Directory can't be null or empty."); //} //if (!Directory.Exists(assemblyLocation.Directory.FullName)) //{ // throw new InvalidOperationException( // string.Format(CultureInfo.CurrentCulture, // "Directory not found {0}", // assemblyLocation.Directory.FullName)); //} AppDomain childDomain = BuildChildDomain(AppDomain.CurrentDomain); try { Type loaderType = typeof(AssemblyLoader); if (loaderType.Assembly != null) { var loader = (AssemblyLoader)childDomain.CreateInstanceFrom(loaderType.Assembly.Location, loaderType.FullName).Unwrap(); loader.LoadAssembly(assemblyLocation.FullName); namespaces = loader.GetNamespaces(assemblyLocation.Directory.FullName); } return(namespaces); } finally { AppDomain.Unload(childDomain); } }
public void ConvertRequest_DoesLazyGetBufferlessInputStream() { // Need to run this test on different AppDomain because the buffer policy selector in // HttpControllerHandler is static and cached so it's not possible to change in the context of this test. AppDomain newAppDomain = AppDomain.CreateDomain("NewTestAppDomain"); string codeBase = Assembly.GetExecutingAssembly().CodeBase; UriBuilder uri = new UriBuilder(codeBase); string location = Uri.UnescapeDataString(uri.Path); ObjectHandle proxy = newAppDomain.CreateInstanceFrom(location, typeof(RemoteHttpControllerHandlerTest).FullName); RemoteHttpControllerHandlerTest remoteTest = proxy.Unwrap() as RemoteHttpControllerHandlerTest; ConvertRequest_DoesLazyGetBufferlessInputStream_TestResults results; try { results = remoteTest.ConvertRequest_DoesLazyGetBufferlessInputStream(); } finally { if (newAppDomain != null) { AppDomain.Unload(newAppDomain); } } Assert.False(results.inputStreamCalledBeforeContentIsRead); Assert.True(results.inputStreamCalledAfterContentIsRead); }
/// <summary> /// Instance method that creates a RazorHost in a new AppDomain. /// This method requires that you keep the Factory around in /// order to keep the AppDomain alive and be able to unload it. /// </summary> /// <returns></returns> public RazorEngine <TBaseTemplateType> GetRazorHostInAppDomain() { _localAppDomain = CreateAppDomain(null); if (_localAppDomain == null) { return(null); } RazorEngine <TBaseTemplateType> host; try { var ass = Assembly.GetExecutingAssembly(); var assemblyPath = ass.Location; host = (RazorEngine <TBaseTemplateType>)_localAppDomain.CreateInstanceFrom(assemblyPath, typeof(RazorEngine <TBaseTemplateType>).FullName).Unwrap(); } catch (Exception ex) { ErrorMessage = ex.Message; return(null); } return(host); }
private static AppDomain CreateTestDomain(string baseDirectory, bool assemblyResolver) { AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationBase = baseDirectory; setup.ApplicationName = "testdomain"; AppDomain ad = AppDomain.CreateDomain("testdomain", AppDomain.CurrentDomain.Evidence, setup); if (assemblyResolver) { Assembly ea = Assembly.GetExecutingAssembly(); ad.CreateInstanceFrom(ea.CodeBase, typeof(AssemblyResolveHandler).FullName, false, BindingFlags.Public | BindingFlags.Instance, null, new object [] { ea.Location, ea.FullName }, CultureInfo.InvariantCulture, null, null); } return(ad); }
static void Main(string[] args) { //AppDomain current = AppDomain.CurrentDomain; //Console.WriteLine("Current Domain : " + current.FriendlyName); //foreach (Assembly asm in current.GetAssemblies()) //{ // Console.WriteLine("Assembly : " + asm.FullName); // foreach (Module m in asm.GetModules()) // { // Console.WriteLine("Module : " + m.FullyQualifiedName); // foreach (Type t in m.GetTypes()) // { // Console.WriteLine("Type : " + t.FullName); // foreach (MemberInfo mi in t.GetMembers()) // { // Console.WriteLine("Member : " + mi.Name); // } // } // } //} AppDomain newAppDomain = AppDomain.CreateDomain("MyAppDomain"); string dllPath = @"E:\Programming\C#\Study_CSharp\Test_Library\bin\Debug\Test_Library.dll"; ObjectHandle objHandle1 = newAppDomain.CreateInstanceFrom(dllPath, "Test_Library.Class1"); //AppDomain.Unload(newAppDomain); AppDomain.CurrentDomain.CreateInstanceFrom(dllPath, "Test_Library.Class2"); //AppDomain.Unload(AppDomain.CurrentDomain); Console.WriteLine("objHandle1 : " + objHandle1.ToString()); }
/// <summary> /// Gets the requested type from the just created weaved assembly /// </summary> /// <param name="name">Name of the type to return.</param> /// <returns></returns> public object CreateInstance(string name) { var type = _assembly.GetTypes().Single(x => x.Name == name); var instance = _domain.CreateInstanceFrom(_assemblyPath, type.FullName); return(instance); }
/// <summary> /// TypeParser Factory method that loads the TypeParser /// object into a new AppDomain so it can be unloaded. /// Creates AppDomain and creates type. /// </summary> /// <returns></returns> public TypeParserLegacy CreateTypeParser() { if (!CreateAppDomain(null)) { return(null); } // *** Use a custom Assembly Resolver that looks in the CURRENT directory // this.LocalAppDomain.AssemblyResolve += new ResolveEventHandler( TypeParserFactory.ResolveAssembly ); /// Create the instance inside of the new AppDomain /// Note: remote domain uses local EXE's AppBasePath!!! TypeParserLegacy parserLegacy = null; try { Assembly assembly = Assembly.GetExecutingAssembly(); string assemblyPath = Assembly.GetExecutingAssembly().Location; object objparser = LocalAppDomain.CreateInstanceFrom(assemblyPath, typeof(TypeParserLegacy).FullName).Unwrap(); parserLegacy = (TypeParserLegacy)objparser; } catch (Exception ex) { ErrorMessage = ex.GetBaseException().Message; return(null); } return(parserLegacy); }
public static void Main(IntPtr portAddress) { // Retrieve Assemblies from the "Libraries" folder. AppDomain.CurrentDomain.AssemblyResolve += LocalAssemblyFinder.ResolveAppDomainAssembly; // Try restarting in another AppDomain if possible. try { // Give the new AppDomain full permissions. PermissionSet permissionSet = new PermissionSet(PermissionState.Unrestricted); permissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.AllFlags)); // The ApplicationBase of the new domain should be the directory containing the current DLL. AppDomainSetup appDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(typeof(InitProxy).Assembly.Location) }; _childDomain = AppDomain.CreateDomain("Reloaded", null, appDomainSetup, permissionSet); // Now make the new AppDomain load our code using our proxy. Type proxyType = typeof(InitProxy); dynamic initProxy = _childDomain.CreateInstanceFrom(proxyType.Assembly.Location, proxyType.FullName).Unwrap(); // Our AssemblyResolve will pick the missing DLL out. initProxy.Run(portAddress); } catch (Exception ex) { Initialize(portAddress); } }
public bool Load() { //create the appdomain, base directory should be set to the packages base directory which should have the assembly containing the proxy in it AppDomainSetup setupInfo = new AppDomainSetup(); setupInfo.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase; setupInfo.ApplicationName = _appDomainName; setupInfo.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; _appDomain = AppDomain.CreateDomain(_appDomainName, AppDomain.CurrentDomain.Evidence, setupInfo); try { //log4net.Repository.Hierarchy.Hierarchy hierachy = (log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository(); log.Debug("Creating domain proxy for AppDomain: " + _appDomainName); //create the domain proxy Type proxyType = typeof(AssemblyLoadProxy); _loadProxy = (AssemblyLoadProxy)_appDomain.CreateInstanceFrom(proxyType.Assembly.Location, proxyType.FullName).Unwrap(); _loadProxySponsor = new LifetimeSponsor(_loadProxy); log.Debug("Initializing cross-domain logging for AppDomain: " + _appDomainName); _loadProxy.InitializeLogging(new Logging.CrossDomainParentAppender()); } catch (Exception ex) { //log.Error("An error occurred initializing the domain proxy for AppDomain: " + _appDomainName, ex); //return false; throw; } return(true); }
private static void GenerateWin32ManifestFileUsingHelper(string strAssemblyManifestFileName, string strAssemblyName, bool bGenerateTypeLib, string strReferenceFiles, string strAsmPath) { string directoryName = Path.GetDirectoryName(strAssemblyName); AppDomainSetup info = new AppDomainSetup { ApplicationBase = directoryName }; AppDomain domain = AppDomain.CreateDomain("GenMan32", null, info); if (domain == null) { throw new ApplicationException(Resource.FormatString("Err_CannotCreateAppDomain")); } try { ObjectHandle handle = domain.CreateInstanceFrom(Assembly.GetExecutingAssembly().CodeBase, typeof(Win32ManifestGenerator).FullName); if (handle == null) { throw new ApplicationException(Resource.FormatString("Err_CannotCreateRemoteWin32ManGen")); } ((Win32ManifestGenerator)handle.Unwrap()).GenerateWin32ManifestFile(strAssemblyManifestFileName, strAssemblyName, bGenerateTypeLib, strReferenceFiles, strAsmPath); } finally { AppDomain.Unload(domain); } }
public IEnumerable <IModelTermProvider> Interrogate() { if (!File.Exists(PackagePath)) { throw new FileNotFoundException("The file: " + Path.GetFileName(PackagePath) + " was not found in " + Path.GetDirectoryName(PackagePath) + "."); } string domainName = Path.GetFileNameWithoutExtension(PackagePath); AppDomainSetup setupInfo = new AppDomainSetup(); setupInfo.ApplicationName = domainName; setupInfo.ApplicationBase = AppDomainBase; _appDomain = AppDomain.CreateDomain(domainName, AppDomain.CurrentDomain.Evidence, setupInfo); Type proxyType = typeof(PackageInterrogationProxy); _interrogationProxy = (PackageInterrogationProxy)_appDomain.CreateInstanceFrom(proxyType.Assembly.Location, proxyType.FullName).Unwrap(); return(_interrogationProxy.Interrogate(PackagePath).Select( termProvider => { System.Runtime.Remoting.Lifetime.ILease leaseObj = System.Runtime.Remoting.RemotingServices.GetLifetimeService((ProxyModelTermProvider)termProvider) as System.Runtime.Remoting.Lifetime.ILease; if (leaseObj != null) { Sponsors.Add(new LifetimeSponsor(leaseObj)); } return termProvider; } )); }
private static string GenerateTypeLibUsingHelper(string strAssemblyName) { string directoryName = Path.GetDirectoryName(strAssemblyName); string strTlbName = null; AppDomainSetup info = new AppDomainSetup { ApplicationBase = directoryName }; AppDomain domain = AppDomain.CreateDomain("GenMan32", null, info); if (domain == null) { throw new ApplicationException(Resource.FormatString("Err_CannotCreateAppDomain")); } try { ObjectHandle handle = domain.CreateInstanceFrom(Assembly.GetExecutingAssembly().CodeBase, typeof(TypeLibGenerator).FullName); if (handle == null) { throw new ApplicationException(Resource.FormatString("Err_CannotCreateRemoteTypeLibGenerator")); } ((TypeLibGenerator)handle.Unwrap()).GenerateTypeLib(strAssemblyName, ref strTlbName); } finally { AppDomain.Unload(domain); } if ((strTlbName != null) && !s_Options.m_bSilentMode) { Console.WriteLine(Resource.FormatString("Msg_TlbGenerated", strAssemblyName)); } return(strTlbName); }
private IStoryHandler GetHandler() { //return // Activator.CreateInstanceFrom( // _assemblyLocation, // "StorEvilTestAssembly.StorEvilDriver", true, 0, null, new object[] {_eventBus}, // CultureInfo.CurrentCulture, new object[0], AppDomain.CurrentDomain.Evidence) as IStoryHandler; // Construct and initialize settings for a second AppDomain. var domainSetup = new AppDomainSetup(); if (InTest) { domainSetup.ApplicationBase = Environment.CurrentDirectory; domainSetup.DisallowBindingRedirects = false; } else { domainSetup.ApplicationBase = Path.GetDirectoryName(_assemblyLocations.First()); domainSetup.DisallowBindingRedirects = false; } domainSetup.ShadowCopyFiles = "true"; domainSetup.ShadowCopyDirectories = GetDirectories(_assemblyLocations); domainSetup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; // Create the second AppDomain. _appDomain = AppDomain.CreateDomain("TestDomain", null, domainSetup); return(_appDomain.CreateInstanceFrom( _assemblyLocation, "StorEvilTestAssembly.StorEvilDriver", true, 0, null, new object[] { _eventBus }, CultureInfo.CurrentCulture, new object[0]).Unwrap() as IStoryHandler); }
private bool ValidateCachedAssemblyVersion(string path) { AppDomain domain = AppDomain.CreateDomain("VersionChecker", new Evidence(AppDomain.CurrentDomain.Evidence), AppDomain.CurrentDomain.SetupInformation); try { Type checkerType = typeof(VersionChecker); var checker = (VersionChecker)domain. CreateInstanceFrom( checkerType.Assembly.Location, checkerType.FullName).Unwrap(); checker.LoadAssembly(path); string version = checker.GetVersion(); if (version != Program.GetProgramVersionInfo()) { return(false); } return(EnsureMethodsExist(checker.GetMethods())); } finally { AppDomain.Unload(domain); } }
private void ParseDirectory(string directory) { ////DirectoryInfo di = new DirectoryInfo(directory); string expandedDirectory = Path.GetFullPath(Environment.ExpandEnvironmentVariables(directory)); string fileName = Path.GetFileName(expandedDirectory); string[] candidateAssemblyPaths = Directory.GetFiles(expandedDirectory, string.Format(CultureInfo.InvariantCulture, @"{0}.dll", fileName), SearchOption.TopDirectoryOnly); if (candidateAssemblyPaths.Length > 0) { AppDomain childAppDomain = this.CreateChildAppDomain(AppDomain.CurrentDomain, expandedDirectory); Type loaderType = typeof(InnerModuleInfoLoader); try { InnerModuleInfoLoader loader = (InnerModuleInfoLoader)childAppDomain.CreateInstanceFrom(loaderType.Assembly.Location, loaderType.FullName).Unwrap(); this.Items.AddRange(loader.LoadModules(candidateAssemblyPaths)); } catch (FileNotFoundException) { // Continue loading assemblies even if an assembly can not be loaded in the new AppDomain } finally { AppDomain.Unload(childAppDomain); } } foreach (string d in Directory.GetDirectories(expandedDirectory)) { ParseDirectory(d); } }
static void Main() { // Construct a path to the current assembly. string assemblyPath = Environment.CurrentDirectory + "\\" + typeof(MarshalableExample).Assembly.GetName().Name + ".exe"; AppDomain ad = AppDomain.CreateDomain("MyDomain"); System.Runtime.Remoting.ObjectHandle oh = ad.CreateInstanceFrom(assemblyPath, "MarshalableExample"); object obj = oh.Unwrap(); // Three ways to use the newly created object, depending on how // much is known about the type: Late bound, early bound through // a mutually known interface, or early binding of a known type. // obj.GetType().InvokeMember("Test", System.Reflection.BindingFlags.InvokeMethod, Type.DefaultBinder, obj, new object[] { "Hello" }); ITest it = (ITest)obj; it.Test("Hi"); MarshalableExample ex = (MarshalableExample)obj; ex.Test("Goodbye"); }
public static void Main() { // Try restarting in another AppDomain if possible. try { // Give the new AppDomain full permissions. PermissionSet permissionSet = new PermissionSet(PermissionState.Unrestricted); permissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.AllFlags)); // The ApplicationBase of the new domain should be the directory containing the current DLL. AppDomainSetup appDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(typeof(InitProxy).Assembly.Location) }; _childDomain = AppDomain.CreateDomain("SA2VsChat", null, appDomainSetup, permissionSet); // Now make the new AppDomain load our code using our proxy. Type proxyType = typeof(InitProxy); dynamic initProxy = _childDomain.CreateInstanceFrom(proxyType.Assembly.Location, proxyType.FullName).Unwrap(); // Our AssemblyResolve will pick the missing DLL out. initProxy.Run(); } catch { Init(); } }
public RazorEngine <T> GetRazorHostInAppDomain() { LocalAppDomain = CreateAppDomain(null); if (LocalAppDomain == null) { return(null); } /// Create the instance inside of the new AppDomain /// Note: remote domain uses local EXE's AppBasePath!!! RazorEngine <T> host = null; try { Assembly ass = Assembly.GetExecutingAssembly(); string AssemblyPath = ass.Location; host = (RazorEngine <T>)LocalAppDomain.CreateInstanceFrom(AssemblyPath, typeof(RazorEngine <T>).FullName).Unwrap(); } catch (Exception ex) { throw ex; } return(host); }
private void PrinterAssemblyInPlace(string assemblyFileFullPath, string workingDirectory) { // Create an AppDomain to load the assembly printer. AppDomainSetup options = new AppDomainSetup(); options.ApplicationBase = workingDirectory; AppDomain domain = AppDomain.CreateDomain("AssemPrinter", null, options); if (domain == null) { MessageBox.Show("Cannot Create AppDomain."); throw new Exception("Cannot Create AppDomain."); } // Create the remote component that will printer the assembly. ObjectHandle h = domain.CreateInstanceFrom(typeof(TlbImpRegressionTestTool.RemoteAssemPrinter).Assembly.CodeBase, "TlbImpRegressionTestTool.RemoteAssemPrinter"); if (h == null) { MessageBox.Show("Failed in Calling Assembly Printer."); throw new Exception("Failed in Calling Assembly Printer."); } RemoteAssemPrinter code = (RemoteAssemPrinter)h.Unwrap(); if (code != null) { code.Run(assemblyFileFullPath); } // Unload the app domain. Now the assembly is unloaded, too. AppDomain.Unload(domain); }
/// <summary> /// Loads an assembly into a new AppDomain and obtains all the /// namespaces in the loaded Assembly, which are returned as a /// List. The new AppDomain is then Unloaded /// </summary> /// <param name="assemblyLocation">The Assembly file /// location</param> /// <returns>A list of found namespaces</returns> public List <String> LoadAssemblies(List <FileInfo> assemblyLocations) { List <String> namespaces = new List <String>(); AppDomain childDomain = BuildChildDomain( AppDomain.CurrentDomain); try { Type loaderType = typeof(AssemblyLoader); if (loaderType.Assembly != null) { AssemblyLoader loader = (AssemblyLoader)childDomain. CreateInstanceFrom( loaderType.Assembly.Location, loaderType.FullName).Unwrap(); namespaces = loader.LoadAssemblies( assemblyLocations); } return(namespaces); } finally { AppDomain.Unload(childDomain); } }
public static void GetFullNameOfClassThatInheritsFromApplication(string pathOfAssemblyThatContainsEntryPoint, out string applicationClassFullName, out string assemblyName, out string assemblyFullName) { //----------------- // Thanks to: http://www.c-sharpcorner.com/UploadFile/girish.nehte/how-to-unload-an-assembly-loaded-dynamically-using-reflection/ //----------------- // Load the assembly in a new AppDomain mainly so that we are able to unload it, which is necessary when we want to delete all temporary files including this assembly. AppDomainSetup setupInformation = AppDomain.CurrentDomain.SetupInformation; AppDomain newAppDomain = AppDomain.CreateDomain("newAppDomain", AppDomain.CurrentDomain.Evidence, setupInformation); //Create an instance of the inspector class in the new domain: //System.Runtime.Remoting.ObjectHandle obj = newAppDomain.CreateInstance(typeof(AssemblyInspectorOnOtherDomain).Assembly.FullName, typeof(AssemblyInspectorOnOtherDomain).FullName); string pathOfThisVeryAssembly = PathsHelper.GetPathOfThisVeryAssembly(); System.Runtime.Remoting.ObjectHandle obj = newAppDomain.CreateInstanceFrom(pathOfThisVeryAssembly, typeof(AssemblyInspectorOnOtherDomain).FullName); IAssemblyInspectorOnOtherDomain inspector = (IAssemblyInspectorOnOtherDomain)obj.Unwrap(); // As the object we are creating is from another appdomain hence we will get that object in wrapped format and hence in next step we have unwrappped it // Call LoadAssembly method so that the assembly will be loaded into the new appdomain amd the object will also remain in new appdomain only: inspector.LoadAssembly(pathOfAssemblyThatContainsEntryPoint); // Call the method that finds the type that inherits from Application: applicationClassFullName = inspector.FindApplicationClassFullName(); // Get the assembly name and full name too: assemblyName = inspector.GetAssemblyName(); assemblyFullName = inspector.GetAssemblyFullName(); // Unload the assembly (so that we can later delete it if necessary): AppDomain.Unload(newAppDomain); GC.Collect(); // Collects all unused memory GC.WaitForPendingFinalizers(); // Waits until GC has finished its work GC.Collect(); }
private void EnsureModulesDiscovered() { if (_modules == null) { AppDomain childDomain = BuildChildDomain(AppDomain.CurrentDomain); try { List <string> loadedAssemblies = new List <string>(); var assemblies = ( from Assembly assembly in AppDomain.CurrentDomain.GetAssemblies() where !(assembly is System.Reflection.Emit.AssemblyBuilder) && !String.IsNullOrEmpty(assembly.Location) select assembly.Location ); loadedAssemblies.AddRange(assemblies); Type loaderType = typeof(InnerModuleInfoLoader); if (loaderType.Assembly != null) { var loader = (InnerModuleInfoLoader)childDomain.CreateInstanceFrom(loaderType.Assembly.Location, loaderType.FullName).Unwrap(); loader.LoadAssemblies(loadedAssemblies); _modules = loader.GetModuleInfos(path); } } finally { AppDomain.Unload(childDomain); } } }
[Category("MobileNotWorking")] // SIGSEGV, probably on AppDomain.Unload public void WeakHandleWorksOnNonRootDomain() { //Console.WriteLine("current app domain: " + AppDomain.CurrentDomain.Id); AppDomain domain = AppDomain.CreateDomain("testdomain"); Assembly ea = Assembly.GetExecutingAssembly(); domain.CreateInstanceFrom(ea.CodeBase, typeof(AssemblyResolveHandler).FullName, false, BindingFlags.Public | BindingFlags.Instance, null, new object [] { ea.Location, ea.FullName }, CultureInfo.InvariantCulture, null, null); var testerType = typeof(CrossDomainGCHandleRunner); var r = (CrossDomainGCHandleRunner)domain.CreateInstanceAndUnwrap( testerType.Assembly.FullName, testerType.FullName, false, BindingFlags.Public | BindingFlags.Instance, null, new object [0], CultureInfo.InvariantCulture, new object [0], null); Assert.IsTrue(r.RunTest(), "#1"); AppDomain.Unload(domain); }
private static void CreateAndUnwrap(AppDomain domain) { var dll = AppDomain.CurrentDomain.BaseDirectory + "plugin.dll"; var handle = domain.CreateInstanceFrom(dll, "Plugin.ConsolePlugin"); var ins = (AppDomainComponent)handle.Unwrap(); ins.Start(); }
public CrossDomainTextWriter(AppDomain domain, TextWriter writer) { this.remoteTracer = domain.CreateInstanceFrom(Assembly.GetExecutingAssembly().Location, typeof(CrossDomainTextWriter).FullName).Unwrap() as CrossDomainTextWriter; if (remoteTracer != null) { remoteTracer.StartListening(this, writer); } }
public CrossDomainProxy(AppDomain domain) { this.domain = domain; var proxyObjectHandle = domain.CreateInstanceFrom(Assembly.GetExecutingAssembly().Location, typeof(InDomainHost).FullName); inDomainHost = (InDomainHost)proxyObjectHandle.Unwrap(); }
static int LoadAPEIPC(IntPtr apePid) { try { int APEPID = apePid.ToInt32(); string APEProcessId = apePid.ToString(); string AUTProcessId = Process.GetCurrentProcess().Id.ToString(); RegistryKey key = Registry.CurrentUser.CreateSubKey("Software").CreateSubKey("APE"); string APEPath = (string)key.GetValue(APEProcessId + "_Path_" + AUTProcessId, null); string AppDomainToLoadInto = (string)key.GetValue(APEProcessId + "_AppDomain_" + AUTProcessId, null); key.DeleteValue(APEProcessId + "_Path_" + AUTProcessId); key.DeleteValue(APEProcessId + "_AppDomain_" + AUTProcessId); key.Close(); Assembly assembly = Assembly.LoadFrom(APEPath + @"\APE.Domain.dll"); Type myAPEDomainType = assembly.GetType("APE.Domain.DomainSearch"); AppDomain appDom = null; if (AppDomainToLoadInto == "DefaultDomain") { if (AppDomain.CurrentDomain.IsDefaultAppDomain()) { appDom = AppDomain.CurrentDomain; } } else { appDom = (AppDomain)myAPEDomainType.InvokeMember("GetAppDomain", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { AppDomainToLoadInto }); } if (appDom == null) { throw new Exception("Failed to find the appdomain " + AppDomainToLoadInto); } bool WPF; Assembly assemblyWPF = appDom.GetAssemblies().FirstOrDefault(x => x.GetName().Name == "WindowsBase"); if (assemblyWPF == null) { WPF = false; } else { WPF = true; } appDom.CreateInstanceFrom(APEPath + @"\APE.Communication.dll", "APE.Communication.APEIPC", false, BindingFlags.Default, null, new object[] { APEPID, AppDomainToLoadInto, WPF }, null, null); return(0); } catch (Exception e) { MessageBox.Show(e.Message + "\r\n" + e.StackTrace); return(-1); } }
private RemoteDirectoryLookupCatalog CreateRemoteDirectoryModuleCatalogInAppDomain(AppDomain testDomain) { RemoteDirectoryLookupCatalog remoteEnum; Type remoteEnumType = typeof(RemoteDirectoryLookupCatalog); remoteEnum = (RemoteDirectoryLookupCatalog)testDomain.CreateInstanceFrom( remoteEnumType.Assembly.Location, remoteEnumType.FullName).Unwrap(); return(remoteEnum); }