C# AppDomain.SetData方法代码示例

        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);
            }
        }

		protected override HostedService CreateRemoteHost(AppDomain appDomain)
		{
			appDomain.SetData("ConnectionString",_connectionString);
			appDomain.DoCallBack(SetConnectionStringInAppDomain);
			var service = base.CreateRemoteHost(appDomain);
			return service;
		}

 public static void SetShadowPathForNativeDll(AppDomain appDomain, string dllFileName, string dllPath)
 {
     if (dllFileName == null) throw new ArgumentNullException("dllFileName");
     if (dllPath == null) throw new ArgumentNullException("dllPath");
     var key = AppDomainCustomDllPathKey + dllFileName.ToLowerInvariant();
     appDomain.SetData(key, dllPath);
 }

        private void simpleButton1_Click(object sender, EventArgs e)
        {
            OpenFileDialog configform = new OpenFileDialog();
            configform.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
            configform.Filter = "程序集文件(*.dll,*.exe)|*.dll;*.exe";
            configform.FilterIndex = 1;
            configform.RestoreDirectory = true;
            if (configform.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    if (currentDomain != null)
                        AppDomain.Unload(currentDomain);
                    currentDomain = AppDomain.CreateDomain("temp");
                    string configfile = configform.FileName + ".config";
                    string filedic = Path.GetDirectoryName(configform.FileName);
                    var m = typeof(AppDomainSetup).GetMethod("UpdateContextProperty", BindingFlags.NonPublic | BindingFlags.Static);
                    var funsion = typeof(AppDomain).GetMethod("GetFusionContext", BindingFlags.NonPublic | BindingFlags.Instance);
                    if(File.Exists(configfile))
                        currentDomain.SetData("APP_CONFIG_FILE", configfile);
                    var test = currentDomain.SetupInformation;
                    exDataAccess = (ExDataAccess)currentDomain.CreateInstanceAndUnwrap(typeof(ExDataAccess).Assembly.FullName, typeof(ExDataAccess).FullName);
                    currentDomain.SetData("APPBASE", filedic);
                    m.Invoke(null, new object[] { funsion.Invoke(currentDomain, null), "APPBASE", filedic });
                    this.textEdit1.Text = configform.FileName;
                    var results = exDataAccess.FindAttributes(configform.FileName);
                    if (results.Count > 0)
                    {
                        this.treeList1.ClearNodes();
                        foreach (var result in results)
                        {
                            this.treeList1.Nodes.Add(result[0], result[1], result[2]);
                        }
                    }

                    currentDomain.SetupInformation.ConfigurationFile =configform.FileName+".config";
                }
                catch(Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
        }

        //private static void domain_DomainUnload(object sender, EventArgs e)
        //{
        //    Trace.WriteLine("domain_DomainUnload()");
        //}

        static void Run(object runSourceRestartParameters)
        {
            __domain = AppDomain.CreateDomain(__runsourceDomainName);
            if (runSourceRestartParameters != null)
            {
                __domain.SetData(__domainRestartParametersName, runSourceRestartParameters);
                runSourceRestartParameters = null;
            }
            __domain.ExecuteAssembly(Path.Combine(zapp.GetAppDirectory(), __runsourceExeName));
        }

		public void ConfigureNewDomain(AppDomain domain)
		{
			if (!string.IsNullOrWhiteSpace(AssemblyFolder))
				domain.SetData("Folder", AssemblyFolder);

			if (domain == AppDomain.CurrentDomain)
				ResolveCustomAssemblies();
			else
				domain.DoCallBack(new CrossAppDomainDelegate(ResolveCustomAssemblies));
		}

 //ncrunch: no coverage start
 public AssemblyStarter(string assemblyFilePath, bool copyToLocalFolderForExecution)
 {
     if (!File.Exists(assemblyFilePath))
         throw new FileNotFoundException("Assembly not found, unable to start it", assemblyFilePath);
     rememberedDirectory = Directory.GetCurrentDirectory();
     var assemblyFullPath = GetFullPathFromRelativeOrAbsoluteFilePath(assemblyFilePath);
     if (copyToLocalFolderForExecution)
         CopyAssemblyFileAndAllDependencies(assemblyFullPath);
     else if (!string.IsNullOrEmpty(assemblyFullPath))
         Directory.SetCurrentDirectory(assemblyFullPath);
     domain = AppDomain.CreateDomain(DomainName, null, CreateDomainSetup(assemblyFullPath));
     domain.SetData("EntryAssembly", Path.GetFullPath(assemblyFilePath));
 }

        protected override IManagedAppBase CreateAndStartServerInstance()
        {
            IManagedApp appServer;

            try
            {
                m_HostDomain = CreateHostAppDomain();

                m_HostDomain.SetData(typeof(IsolationMode).Name, IsolationMode.AppDomain);

                var marshalServerType = typeof(MarshalManagedApp);

                appServer = (IManagedApp)m_HostDomain.CreateInstanceAndUnwrap(marshalServerType.Assembly.FullName,
                    marshalServerType.FullName,
                    true,
                    BindingFlags.CreateInstance,
                    null,
                    new object[] { GetMetadata().AppType },
                    null,
                    new object[0]);

                if (!appServer.Setup(Bootstrap, Config))
                {
                    OnExceptionThrown(new Exception("Failed to setup MarshalManagedApp"));
                    return null;
                }

                if (!appServer.Start())
                {
                    OnExceptionThrown(new Exception("Failed to start MarshalManagedApp"));
                    return null;
                }

                m_HostDomain.DomainUnload += new EventHandler(m_HostDomain_DomainUnload);

                return appServer;
            }
            catch (Exception e)
            {
                if (m_HostDomain != null)
                {
                    AppDomain.Unload(m_HostDomain);
                    m_HostDomain = null;
                }

                OnExceptionThrown(e);
                return null;
            }
        }

        /// <summary>
        /// Starts this server instance.
        /// </summary>
        /// <returns>
        /// return true if start successfull, else false
        /// </returns>
        protected override IWorkItemBase Start()
        {
            IWorkItem appServer;

            try
            {
                m_HostDomain = CreateHostAppDomain();

                m_HostDomain.SetData(typeof(IsolationMode).Name, IsolationMode.AppDomain);

                var marshalServerType = typeof(MarshalAppServer);

                appServer = (IWorkItem)m_HostDomain.CreateInstanceAndUnwrap(marshalServerType.Assembly.FullName,
                        marshalServerType.FullName,
                        true,
                        BindingFlags.CreateInstance,
                        null,
                        new object[] { ServerTypeName },
                        null,
                        new object[0]);

                if (!appServer.Setup(Bootstrap, ServerConfig, Factories))
                {
                    OnExceptionThrown(new Exception("Failed to setup MarshalAppServer"));
                    return null;
                }

                if (!appServer.Start())
                {
                    OnExceptionThrown(new Exception("Failed to start MarshalAppServer"));
                    return null;
                }

                m_HostDomain.DomainUnload += new EventHandler(m_HostDomain_DomainUnload);

                return appServer;
            }
            catch (Exception e)
            {
                if (m_HostDomain != null)
                {
                    AppDomain.Unload(m_HostDomain);
                    m_HostDomain = null;
                }

                OnExceptionThrown(e);
                return null;
            }
        }

 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;
    }
 }

        public ProjectExecutionContext(Project project, IServiceProvider serviceProvider)
        {
            Debug.Assert(project != null, "project is null.");
            Debug.Assert(!VsUtils.IsMiscellaneousProject(project), "project is misc files project.");

            _domain = AppDomain.CreateDomain(
                "ProjectExecutionContextDomain",
                null,
                new AppDomainSetup
                    {
                        ApplicationBase = VsUtils.GetProjectTargetDir(project, serviceProvider),
                        ConfigurationFile = VsUtils.GetProjectConfigurationFile(project, serviceProvider),
                        ShadowCopyFiles = "true" // Prevents locking
                    });

            var dataDirectory = VsUtils.GetProjectDataDirectory(project, serviceProvider);
            if (dataDirectory != null)
            {
                _domain.SetData("DataDirectory", dataDirectory);
            }

            _executor = new ExecutorWrapper(_domain, VsUtils.GetProjectTargetFileName(project));
        }

 /// <summary>
 /// Initializes the application domain with the debugger proxy.
 /// </summary>
 /// <param name="scriptDomain">The script domain.</param>
 internal static void InitializeAppDomain(AppDomain scriptDomain)
 {
     scriptDomain.SetData(VSDebuggerProxy.AppDomainDataName, debuggerProxy);
 }

 public void AssociateWithAppDomain(AppDomain domain) {
     Contract.RequiresNotNull(domain, "domain");
     domain.SetData(AppDomainDataKey, this);
 }

        private void LoadAllRunnersIntoAppDomain()
        {
            domain = AppDomain.CreateDomain("Delta Engine Assembly Updater", null, CreateDomainSetup());
            domain.SetData("resolver", resolver);
            domain.SetData("domainInitializationCode", domainInitializationCode);
            domain.DoCallBack(InitializeInDomain);

            foreach (string assembly in AssemblyFilenames)
                LoadRunners(assembly);
        }

        public void Init(bool fullBind)
        {
            string name = Path.GetRandomFileName();
            tempDir = Path.Combine(Path.GetTempPath(), name);
            string robocodeShadow = Path.Combine(tempDir, Path.GetFileName(robocodeAssembly.Location));
            string hostShadow = Path.Combine(tempDir, Path.GetFileName(hostAssembly.Location));
            string controlShadow = Path.Combine(tempDir, Path.GetFileName(controlAssembly.Location));
            string jniShadow = Path.Combine(tempDir, Path.GetFileName(jniAssembly.Location));

            Directory.CreateDirectory(tempDir);
            File.Copy(robocodeAssembly.Location, robocodeShadow);
            File.Copy(controlAssembly.Location, controlShadow);
            File.Copy(hostAssembly.Location, hostShadow);
            File.Copy(jniAssembly.Location, jniShadow);

            var trustAssemblies = new[]
                                      {
                                          Reflection.GetStrongName(robocodeAssembly),
                                          Reflection.GetStrongName(controlAssembly),
                                          Reflection.GetStrongName(hostAssembly),
                                          Reflection.GetStrongName(jniAssembly),
                                      };
            var domainSetup = new AppDomainSetup();
            Evidence securityInfo = AppDomain.CurrentDomain.Evidence;
            var permissionSet = new PermissionSet(PermissionState.None);
            permissionSet.AddPermission(
                new SecurityPermission(SecurityPermissionFlag.Execution | SecurityPermissionFlag.Assertion));
            permissionSet.AddPermission(new FileIOPermission(FileIOPermissionAccess.Read, tempDir));
            permissionSet.AddPermission(new UIPermission(PermissionState.None));
            //permissionSet.AddPermission(HostProtection);

            domainSetup.ApplicationBase = tempDir;

            domainSetup.ApplicationName = name;
            //domainSetup.SandboxInterop = true;
            domainSetup.DisallowBindingRedirects = true;
            domainSetup.DisallowCodeDownload = true;
            domainSetup.DisallowPublisherPolicy = true;
            domainSetup.AppDomainInitializer = AppDomainSeed.Load;
            

            domain = AppDomain.CreateDomain(name, securityInfo, domainSetup, permissionSet, trustAssemblies);
            domain.SetData("fullBind", fullBind);
            domain.SetData("JavaHome", Bridge.Setup.JavaHome);
            domain.DoCallBack(AppDomainSeed.Bind);
        }