private ICustomConfigAssemblyInspector CreateAppDomain() { AppDomainSetup setup = new AppDomainSetup(); #if DEBUG setup.ApplicationBase = @"E:\db4object\db4o\Trunk\omn\OMADDIN\bin\"; #else setup.ApplicationBase = CommonForAppDomain.GetPath() + "\\"; #endif setup.ShadowCopyDirectories = Path.GetTempPath(); setup.ShadowCopyFiles = "true"; workerAppDomain = AppDomain.CreateDomain("CustomConfigWorkerAppDomain", null, setup); AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve); object anObject = workerAppDomain.CreateInstanceAndUnwrap("OMCustomConfigImplementation", "OMCustomConfigImplementation.CustomConfigAssemblyInfo.CustomConfigAssemblyInspector"); ICustomConfigAssemblyInspector customConfigAssemblyInspector = anObject as ICustomConfigAssemblyInspector; object anObject1 = workerAppDomain.CreateInstanceAndUnwrap("OMCustomConfigImplementation", "OMCustomConfigImplementation.UserCustomConfig.UserConfig"); IUserConfig conn = anObject1 as IUserConfig; CustomConfigInspectorObject.CustomUserConfig = conn; return customConfigAssemblyInspector; }
public void Run(RunnerInvocation invocation, Action<RunnerInvocation> action, string dll) { this.dll = dll; var setup = new AppDomainSetup(); setup.ConfigurationFile = Path.GetFullPath(config); setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); domain = AppDomain.CreateDomain("NSpecDomain.Run", null, setup); var type = typeof(Wrapper); var assemblyName = type.Assembly.GetName().Name; var typeName = type.FullName; domain.AssemblyResolve += Resolve; var wrapper = (Wrapper)domain.CreateInstanceAndUnwrap(assemblyName, typeName); wrapper.Execute(invocation, action); AppDomain.Unload(domain); }
/// <summary> /// Creates a new instance of the test runner in the given app domain. /// </summary> /// <param name="domain">The app domain to create the runner into.</param> /// <param name="package">The test package to execute.</param> /// <returns></returns> public static TestRunner CreateRunner(System.AppDomain domain, TestPackage package) { Contract.Requires(domain != null); var runnerType = typeof(TestRunner); return(domain.CreateInstanceAndUnwrap(runnerType.Assembly.FullName, runnerType.FullName, false, 0, null, new object[] { package }, null, null) as TestRunner); }
private System.AppDomain CreateDomain(string domainName, string containerName) { System.AppDomain appDomain = null; try { // Create the AppDomain for each container and initialize the container with AppDomain appDomain = System.AppDomain.CreateDomain(containerName); // Create an instance of the container in that domain and initialize it. string fullName = typeof(ContainerManager).Assembly.FullName; string typeName = typeof(ContainerManager).FullName; ContainerManager manager = (ContainerManager)appDomain.CreateInstanceAndUnwrap(fullName, typeName); if (manager != null) { appDomain.SetData("ContainerManager", manager); manager.Initialize(domainName, containerName); } } catch (System.Exception ex) { string errorString = GenerateErrorString(ex); if (appDomain != null) { System.AppDomain.Unload(appDomain); appDomain = null; } } return(appDomain); }
void Init(string fileNname, string domainName) { //difference comparing to InitLagacy: // CreateInstanceAndUnwrap instead of CreateInstanceFromAndUnwrap // // setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); // instead of setup.ApplicationBase = Path.GetDirectoryName(assemblyFileName); // // In 2016 just discovered that InitLegacy doesn't longer work. May be because some changes in .NET versions... // This is a low impact change as AssemblyExecutor is only used for cached vs. non-cached execution in stand alone // hosting mode. assemblyFileName = fileNname; AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); setup.PrivateBinPath = AppDomain.CurrentDomain.BaseDirectory; setup.ApplicationName = Utils.GetAssemblyFileName(Assembly.GetExecutingAssembly()); setup.ShadowCopyFiles = "true"; setup.ShadowCopyDirectories = Path.GetDirectoryName(assemblyFileName); appDomain = AppDomain.CreateDomain(domainName, null, setup); remoteExecutor = (RemoteExecutor)appDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(RemoteExecutor).ToString()); remoteExecutor.searchDirs = ExecuteOptions.options.searchDirs; }
internal static void AssertAppDomainHasAssemblyResolveEventSubscribers(int expected, AppDomain appDomain) { var proxy = (AppDomainInfoProvider)appDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(AppDomainInfoProvider).FullName); var subscriberCount = proxy.GetAssemblyResolveEventSubscriberCount(); Assert.Equal(expected, subscriberCount); }
private void StartInternal() { ConfigurationManipulation.RemoveAzureTraceListenerFromConfiguration(_configurationFilePath); CopyStubAssemblyToRoleDirectory(_appDomainSetup.ApplicationBase, _role); _appDomain = AppDomain.CreateDomain("LightBlue", null, _appDomainSetup); _hostStub = (HostStub)_appDomain.CreateInstanceAndUnwrap(typeof(HostStub).Assembly.FullName, typeof(HostStub).FullName); var shipper = new EventTraceShipper(); Action<string> twh = m => _role.TraceWrite(Identifier, m); Action<string> twlh = m => _role.TraceWriteLine(Identifier, m); shipper.TraceWrite += twh; shipper.TraceWriteLine += twlh; _hostStub.ConfigureTracing(shipper); // TODO: decide how this is going to work. _appDomain.UnhandledException += StubExceptionHandler.Handler; try { _started.SetResult(new object()); _role.TraceWriteLine(Identifier, "Role started in app domain: " + _appDomain.Id + " by " + Thread.CurrentThread.Name); _hostStub.Run(_assemblyFilePath, _configurationFilePath, _serviceDefinitionFilePath, _roleName, false); } catch (Exception ex) { _role.TraceWriteLine(Identifier, ex.ToString()); } finally { shipper.TraceWrite -= twh; shipper.TraceWriteLine -= twlh; _completed.SetResult(new object()); } }
protected override HostedService CreateRemoteHost(AppDomain appDomain) { object instance = appDomain.CreateInstanceAndUnwrap("Rhino.ServiceBus", "Rhino.ServiceBus.LoadBalancer.LoadBalancerHost"); var hoster = (LoadBalancerHost)instance; return new HostedService(hoster, "Rhino.ServiceBus", appDomain); }
public static bool Invoke(AppDomain domain, ScriptEnvironmentSetup setup, out RemoteScriptEnvironment environment) { RemoteDelegate rd = (RemoteDelegate)domain.CreateInstanceAndUnwrap(typeof(RemoteDelegate).Assembly.FullName, typeof(RemoteDelegate).FullName, false, BindingFlags.Default, null, new object[] { setup }, null, null, null); environment = rd.Environment; return rd.NewCreated; }
public ContextWrapper Run(string tagOrClassName, RunnerInvocation invocation, Func<RunnerInvocation, ContextWrapper> action, string dll) { this.dll = dll; var setup = new AppDomainSetup(); setup.ConfigurationFile = Path.GetFullPath(config); setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); domain = AppDomain.CreateDomain("NSpecRunnerDomain.Run", null, setup); var type = typeof(Wrapper); var assemblyName = type.Assembly.GetName().Name; var typeName = type.FullName; domain.AssemblyResolve += Resolve; var wrapper = (Wrapper)domain.CreateInstanceAndUnwrap(assemblyName, typeName); var results = wrapper.Execute(invocation, action);// RunContexts(tagOrClassName); AppDomain.Unload(domain); return results; }
/// <summary> /// Creates a new CustomWindowsFormsHost instance that allows hosting controls /// from the specified AppDomain. /// </summary> public CustomWindowsFormsHost(AppDomain childDomain) { var type = typeof(HostedControlContainer); this._container = (HostedControlContainer)childDomain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName); Init(); }
private void InitliazeValidationAppDomain() { m_ValidationAppDomain = AppDomain.CreateDomain("ValidationDomain", AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.BaseDirectory, string.Empty, false); var validatorType = typeof(TypeValidator); m_Validator = (TypeValidator)m_ValidationAppDomain.CreateInstanceAndUnwrap(validatorType.Assembly.FullName, validatorType.FullName); }
public DiaSessionWrapper(string assemblyFilename) { session = new DiaSession(assemblyFilename); var setup = new AppDomainSetup { ApplicationBase = Path.GetDirectoryName(new Uri(typeof(DiaSessionWrapperHelper).Assembly.CodeBase).LocalPath), ApplicationName = Guid.NewGuid().ToString(), LoaderOptimization = LoaderOptimization.MultiDomainHost, ShadowCopyFiles = "true", }; setup.ShadowCopyDirectories = setup.ApplicationBase; setup.CachePath = Path.Combine(Path.GetTempPath(), setup.ApplicationName); appDomain = AppDomain.CreateDomain(setup.ApplicationName, null, setup, new PermissionSet(PermissionState.Unrestricted)); helper = (DiaSessionWrapperHelper)appDomain.CreateInstanceAndUnwrap( assemblyName: typeof(DiaSessionWrapperHelper).Assembly.FullName, typeName: typeof(DiaSessionWrapperHelper).FullName, ignoreCase: false, bindingAttr: 0, binder: null, args: new[] { assemblyFilename }, culture: null, activationAttributes: null, securityAttributes: null ); }
private static System.AppDomain CreateAndRunAppDomain(int index, PermissionSet grantSet) { // Construct and initialize settings for a second AppDomain. AppDomainSetup ads = new AppDomainSetup(); ads.ApplicationBase = System.AppDomain.CurrentDomain.BaseDirectory; ads.DisallowBindingRedirects = false; ads.DisallowCodeDownload = true; ads.ConfigurationFile = System.AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; string name = "AppDomain" + index; System.AppDomain appDomain1 = System.AppDomain.CreateDomain( name, System.AppDomain.CurrentDomain.Evidence, ads, grantSet); AppDomainInstanceProgram programInstance1 = (AppDomainInstanceProgram)appDomain1.CreateInstanceAndUnwrap( typeof(AppDomainInstanceProgram).Assembly.FullName, typeof(AppDomainInstanceProgram).FullName); var argsToPass = new string[] { name, index.ToString() }; programInstance1.Main(argsToPass); Console.WriteLine("**********************************************"); Console.WriteLine($"Finished executing in AppDomain {name}"); Console.WriteLine("**********************************************"); return(appDomain1); }
private void RunScriptCore(byte[] inMemoryAssembly, byte[] inMemorySymbolStore, TextWriter outputTextWriter, TextWriter errorTextWriter) { RemoteScriptRun scriptRun; lock (fieldsLock) { if (inMemoryAssembly != loadedAssembly) { if (scriptAppDomain != null) { AppDomain.Unload(scriptAppDomain); } scriptAppDomain = AppDomain.CreateDomain("ScriptAppDomain"); remoteScriptRun = (RemoteScriptRun)scriptAppDomain.CreateInstanceAndUnwrap(typeof(RemoteScriptRun).Assembly.FullName, typeof(RemoteScriptRun).FullName); remoteScriptRun.Load(inMemoryAssembly, inMemorySymbolStore, outputTextWriter, errorTextWriter); loadedAssembly = inMemoryAssembly; } scriptRun = remoteScriptRun; } try { scriptRun?.Run(); } catch (AppDomainUnloadedException) { } }
public void LoadFrom(string path) { if (_domain != null) { _scanner.Teardown(); AppDomain.Unload(_domain); } var name = Path.GetFileNameWithoutExtension(path); var dirPath = Path.GetFullPath(Path.GetDirectoryName(path)); var setup = new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory, PrivateBinPath = dirPath, ShadowCopyFiles = "true", ShadowCopyDirectories = dirPath, }; _domain = AppDomain.CreateDomain(name + "Domain", AppDomain.CurrentDomain.Evidence, setup); var scannerType = typeof(Scanner); _scanner = (Scanner)_domain.CreateInstanceAndUnwrap(scannerType.Assembly.FullName, scannerType.FullName); _scanner.Load(name); _scanner.Setup(); }
public RemoteDebugger() { // Create a new debugger session mSessionId = Guid.NewGuid().ToString(); Evidence evidence = new Evidence(AppDomain.CurrentDomain.Evidence); AppDomainSetup appDomainSetup = AppDomain.CurrentDomain.SetupInformation; mAppDomain = AppDomain.CreateDomain(String.Format("Debugger-{0}", mSessionId), evidence, appDomainSetup); /* Type assemblyLoaderType = typeof(AssemblyLoader); AssemblyLoader loader = mAppDomain.CreateInstanceAndUnwrap(assemblyLoaderType.Assembly.GetName().Name, assemblyLoaderType.FullName) as AssemblyLoader; foreach (String assemblyPath in Directory.GetFiles(DebuggerConfig.ApplicationPath, "Tridion*.dll")) { loader.LoadAssembly(assemblyPath); } */ Type debuggerHostType = typeof(DebugEngineServer); mDebuggerHost = mAppDomain.CreateInstanceAndUnwrap( debuggerHostType.Assembly.GetName().Name, debuggerHostType.FullName, true, BindingFlags.Default, null, new Object[] { mSessionId }, null, null) as DebugEngineServer; }
/// <summary> /// Starts this instance. /// </summary> /// <exception cref="System.InvalidOperationException">Job already started.</exception> public static void Start() { if (_job != null) throw new InvalidOperationException("Job already started."); var evidence = new Evidence(AppDomain.CurrentDomain.Evidence); var setup = new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase, ShadowCopyFiles = "false" }; _appDomain = AppDomain.CreateDomain("eSync-" + Guid.NewGuid(), evidence, setup); try { var assembly = _appDomain.Load(typeof(SyncServiceJob).Assembly.GetName()); var jobTypeName = typeof(SyncServiceJob).FullName; _job = (IJob)_appDomain.CreateInstanceAndUnwrap(assembly.FullName, jobTypeName); _job.Start(); } catch { _job = null; AppDomain.Unload(_appDomain); _appDomain = null; throw; } }
private static ApplicationProxy CreateProxy(AppDomain domain) { Type activator = typeof(ApplicationProxy); ApplicationProxy proxy = domain.CreateInstanceAndUnwrap( Assembly.GetAssembly(activator).FullName, activator.ToString()) as ApplicationProxy; return proxy; }
public IRemoteDomainBridge ForAppDomain(AppDomain domain) { var t = _ioc.Get<IRemoteDomainBridge>().GetType(); return (IRemoteDomainBridge)domain.CreateInstanceAndUnwrap( t.Assembly.FullName, t.FullName); }
public IIoDeviceWrapper Create() { _appDomain = AppDomain.CreateDomain(_domainName, null, null); var type = typeof (IoDeviceWrapper); var assembly = Assembly.GetAssembly(type); Debug.Assert(type.FullName != null, "type.FullName != null"); return (IIoDeviceWrapper)_appDomain.CreateInstanceAndUnwrap(assembly.FullName, type.FullName); }
private HeartBeat _heartBeater; //TODO pass heartbeater and pass back current users #endregion Fields #region Constructors public LillyPad() { InputOutput.InitLogTypes(); /* * The LillyPad System simply takes each subsystem and starts it * in its own thread, doing this allows us to desync the entire * system and restart subsystems without restarting the whole * server. * */ _historyAppDomain = AppDomain.CreateDomain("History_AppDomain"); Type t = typeof (HistoryController); if (t.FullName != null) _historyController = (HistoryController) _historyAppDomain.CreateInstanceAndUnwrap("MineFrog", t.FullName); _databaseAppDomain = AppDomain.CreateDomain("Database_AppDomain"); t = typeof (DatabaseController); if (t.FullName != null) _databaseController = (DatabaseController)_databaseAppDomain.CreateInstanceAndUnwrap("MineFrog", t.FullName); _heartBeatDomain = AppDomain.CreateDomain("HeartBeat_AppDomain"); t = typeof (HeartBeat); if (t.FullName != null) _heartBeater = (HeartBeat)_historyAppDomain.CreateInstanceAndUnwrap("MineFrog", t.FullName); Server.Log("Starting Server SybSystems...", LogTypesEnum.System); #region TODO Move server to auto-restarter! _serverDomain = AppDomain.CreateDomain("Server_AppDomain"); t = typeof (Server); if (t.FullName != null) _server = (Server) _serverDomain.CreateInstanceAndUnwrap("MineFrog", t.FullName); _server.DONOTUSEMEHistoryControllerNS = _historyController; _server.DONOTUSEMEDatabaseControllerNS = _databaseController; _server.DONOTUSEMEHeartBeatNS = _heartBeater; _server.Start(); //Server.StartInput(); #endregion }
public ScriptContainer(string binPathes, string name) { AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory; setup.PrivateBinPath = binPathes; scriptDomain = AppDomain.CreateDomain("script", null, setup); Type helperType = typeof(ScriptCompilerHelper); helper = scriptDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName) as ScriptCompilerHelper; }
public static MvcTextTemplateHost Create (AppDomain domain) { if (domain == null) return new MvcTextTemplateHost (); return (MvcTextTemplateHost) domain.CreateInstanceAndUnwrap ( typeof (MvcTextTemplateHost).Assembly.FullName, typeof (MvcTextTemplateHost).FullName); }
public Shell(string[] commandLineArguments) { var appDomainSetup = new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory }; testDomain = AppDomain.CreateDomain("fitSharp.Machine", null, appDomainSetup); runner = (Runner) testDomain.CreateInstanceAndUnwrap( Assembly.GetExecutingAssembly().GetName().Name, typeof (Runner).FullName); runner.SetUp(commandLineArguments); }
//--- Constructors --- public IsolatedTypeInspector() { _log.Debug("set up appdomain"); var appDomainSetup = new AppDomainSetup(); string currentBase = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory); appDomainSetup.ApplicationBase = currentBase; _assemblyInspectorDomain = AppDomain.CreateDomain("assembly-inspector", null, appDomainSetup); _typeInspector = (ITypeInspector)_assemblyInspectorDomain.CreateInstanceAndUnwrap("mindtouch.reflection", "MindTouch.Reflection.TypeInspector"); _log.Debug("app domain created"); }
public ContextSwitchTests() { otherDomain = AppDomain.CreateDomain("other domain", null, AppDomain.CurrentDomain.BaseDirectory, null, false); contextSwitcher = (ContextSwitcher)otherDomain.CreateInstanceAndUnwrap( Assembly.GetExecutingAssembly().GetName().Name, typeof(ContextSwitcher).FullName); }
static BatchCompiler NewBatchCompiler () { if (current != null) AppDomain.Unload (current); current = AppDomain.CreateDomain ("test"); BatchCompiler compiler = (BatchCompiler) current.CreateInstanceAndUnwrap( Assembly.GetExecutingAssembly().FullName, "Verifier.BatchCompiler"); return compiler; }
public static void Main() { int one = 1; System.Diagnostics.Debugger.Break(); System.AppDomain appDomain = System.AppDomain.CreateDomain("myDomain"); RemoteObj printer = (RemoteObj)appDomain.CreateInstanceAndUnwrap(typeof(RemoteObj).Assembly.FullName, typeof(RemoteObj).FullName); printer.Foo(); }
public Remoter() { //Create an AppDomain in which to run our DLL code AppDomainSetup appDomainSetup = new AppDomainSetup(); appDomainSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory; //Environment.CurrentDirectory disposableAppDomain = AppDomain.CreateDomain("DisposableAppDomain" + Guid.NewGuid().ToString(), null, appDomainSetup); //disposableAppDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve); //Create the remoteLoaderFactory class in the secondary app-domain //remoteLoaderFactory = (RemoteLoaderFactory)disposableAppDomain.CreateInstanceAndUnwrap("RemoteLoader", "RemoteLoader.RemoteLoaderFactory"); remoteContainer = (RemoteContainer)disposableAppDomain.CreateInstanceAndUnwrap("RemoteContainer", "RemoteLoader.RemoteContainer"); }
public void Start() { if (Id == null) throw new InvalidOperationException("Run Configure() first."); _appDomain = AppDomain.CreateDomain(_appName, null, _appDomainSetup); _domainManager = (AppInitializeRunner) _appDomain.CreateInstanceAndUnwrap("Griffin.Core", typeof (AppInitializeRunner).FullName); _domainManager.Start(Id, _startType.AssemblyQualifiedName); }
static void Load() { if (pluginDomain != null) { Unload(); } pluginDomain = AppDomain.CreateDomain("PluginDomain" + Guid.NewGuid()); var t = typeof (PluginLoader); loader = (PluginLoader) pluginDomain.CreateInstanceAndUnwrap(t.Assembly.FullName, t.FullName); loader.Load("Plugin1.dll"); }
public TestObjectMarshall CreateObject(TestObjectMarshall testObject, AppDomain appDomain, string exeAssembly) { // Create an instance of MarshalbyRefType in the second AppDomain. // A proxy to the object is returned. testObject = (TestObjectMarshall)appDomain.CreateInstanceAndUnwrap( exeAssembly, typeof(TestObjectMarshall).FullName ); return testObject; }
private TestRunner MakeRemoteTestRunner( AppDomain runnerDomain ) { Type runnerType = typeof( RemoteTestRunner ); object obj = runnerDomain.CreateInstanceAndUnwrap( runnerType.Assembly.FullName, runnerType.FullName, false, BindingFlags.Default,null,new object[] { this.ID },null,null,null); RemoteTestRunner runner = (RemoteTestRunner) obj; return runner; }
public T CreateProxy <T> (Type proxyType, params object[] proxyArgs) { var instance = _appDomain.CreateInstanceAndUnwrap( proxyType.Assembly.GetName().Name, proxyType.FullName, ignoreCase: false, bindingAttr: c_bindingFlags, binder: null, args: proxyArgs, culture: CultureInfo.InvariantCulture, activationAttributes: null); return((T)instance); }
public static T CreateProxy <T> (this System.AppDomain appDomain, Type proxyType, params object[] proxyArgs) { Debug.Assert(proxyType.IsSubclassOf(typeof(MarshalByRefObject)), "proxyType.IsSubclassOf(typeof(MarshalByRefObject))"); var instance = appDomain.CreateInstanceAndUnwrap( proxyType.Assembly.GetName().Name, proxyType.FullName, ignoreCase: false, bindingAttr: c_bindingFlags, binder: null, args: proxyArgs, culture: CultureInfo.InvariantCulture, activationAttributes: null); return((T)instance); }
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 T LoadProxy <T>() where T : MarshalByRefObject { var type = typeof(T); return((T)_domain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName)); }
public ContinuousDatabaseAppDomainProxy() { _domain = System.AppDomain.CreateDomain("ContinuousDatabaseActivity"); _remoteClass = _domain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(ContinuousDatabaseAppDomain).FullName) as ContinuousDatabaseAppDomain; }