Пример #1
0
        public void LaunchAppDomain(int param)
        {
            UnloadAppDomain();
            QAppDomain = AppDomain.CreateDomain("QAppDomain");
            AppDomain.MonitoringIsEnabled = true;

            string path = Win32Hooks.HookManager.Instance.AssemblyPath;

            switch (param)
            {
            case 0:
                //QuestorManagerDomain.ExecuteAssembly(assemblyFolder + "\\Questor\\Questor.exe",args: new String[] {"-i"});
                t = new Thread(delegate() { QAppDomain.ExecuteAssembly(path + "\\Questor\\Questor.exe", args: new String[] { "-i", "-c", Win32Hooks.HookManager.Instance.CharName, "-u", Win32Hooks.HookManager.Instance.AccountName, "-p", Win32Hooks.HookManager.Instance.Password }); });
                t.Start();
                break;

            case 1:
                t = new Thread(delegate() { QAppDomain.ExecuteAssembly(path + "\\Questor\\QuestorManager.exe", args: new String[] { "-i" }); });
                t.Start();
                break;

            case 2:
                t = new Thread(delegate() { QAppDomain.ExecuteAssembly(path + "\\Questor\\ValueDump.exe", args: new String[] { "-i" }); });
                t.Start();
                break;

            default:
                break;
            }
        }
Пример #2
0
    static int Main(string[] args)
    {
        switch (args.Length)
        {
        case 0:
            Console.WriteLine("Create a restricted sandbox to execute an assembly.");
            Console.WriteLine("Usage: mono sandbox.exe [@namedpermissionset | permissionset.xml] assembly.exe [parameters ...]");
            return(0);

        case 1:
            Console.WriteLine("Using default (current) appdomain to load '{0}'...", args [0]);
            return(AppDomain.CurrentDomain.ExecuteAssembly(args [0]));

        case 2:
            AppDomain ad = CreateRestrictedDomain(args [0]);
            return(ad.ExecuteAssembly(args [1]));

        default:
            ad = CreateRestrictedDomain(args [0]);
            string[] newargs = new string [args.Length - 2];
            for (int i = 2; i < args.Length; i++)
            {
                newargs [i - 2] = args [i];
            }
            return(ad.ExecuteAssembly(args [1], null, newargs));
        }
    }
        public static void DoScan(TestContext context)
        {
            string            tempProjectPath   = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
            DirectorySecurity directorySecurity = new DirectorySecurity();

            directorySecurity.AddAccessRule(new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow));

            tempProjectDirectory = Directory.CreateDirectory(tempProjectPath, directorySecurity);
            AppDomain scanDomain = AppDomain.CreateDomain("Scanner Test Domain");

            try
            {
                ZipFile.ExtractToDirectory(@"TestApp.zip", tempProjectPath);

                string executablePath = Path.Combine(tempProjectDirectory.FullName, "QuackHackAdmin.exe");
                string outputFilePath = Path.Combine(tempProjectDirectory.FullName, "scanresult.json");
                scanDomain.ExecuteAssembly("Scanner.exe", new string[] { executablePath, "-o", outputFilePath });
                string scanResultJsonText = File.ReadAllText(outputFilePath);
                Assert.IsFalse(string.IsNullOrWhiteSpace(scanResultJsonText));
                //Construct the Json
                scanOutputJson = JsonConvert.DeserializeObject <JObject>(scanResultJsonText);
            }
            finally
            {
                AppDomain.Unload(scanDomain);
                tempProjectDirectory.Delete(true);
            }
        }
Пример #4
0
        public void CanLaunchExeFromWithinSameProcessAsThis()
        {
            AppDomain domain = AppDomain.CreateDomain("Testing");

            domain.ExecuteAssembly("Eca.Spikes.WinFormsApplication.exe");
            AppDomain.Unload(domain);
        }
        static void Main(string[] args)
        {
            AppDomain testApp = AppDomain.CreateDomain("testApp");

            try
            {
                args = new string[] { };
                string path = ConfigurationManager.AppSettings.Get("testApp");

                //subscribe to ProcessExit before executing the assembly
                testApp.ProcessExit += (sender, e) =>
                {
                    //do nothing or do anything
                    Console.WriteLine("The appdomain ended");
                    Console.WriteLine("Press any key to end this program");
                    Console.ReadKey();
                };

                testApp.ExecuteAssembly(path);
            }
            catch (Exception ex)
            {
                //Catch process here
            }
            finally
            {
                AppDomain.Unload(testApp);
            }
        }
Пример #6
0
        [STAThread] // This is needed for WPF apps, not sure about other
        //TODO: would there be a case where MTA is needed?
        //"they must protect their internal state against concurrent calls, in case they're loaded in the MTA, but must not block, in case they're loaded in an STA."
        //http://stackoverflow.com/a/127340/66372
        //"If you're only going to consume COM components all that you really need to know is that you have to match the apartment to the component or nasty things will happen."
        //http://stackoverflow.com/a/485109/66372
        static void Main(string[] args)
        {
            string OSBOXPARAMS = Environment.GetEnvironmentVariable("OSBOXPARAMS");
            int    delimPos    = OSBOXPARAMS.IndexOf(" ");
            //TODO: could an access violation exception be coming from .OpenExisting - http://msdn.microsoft.com/en-US/library/530zssyk(v=VS.80).aspx
            //  i.e. "If you run the compiled example from two command windows, the second copy will throw an access violation exception on the call to OpenExisting(String)."
            EventWaitHandle injectionDone = EventWaitHandle.OpenExisting(OSBOXPARAMS.Substring(0, delimPos));
            string          assemblyPath  = OSBOXPARAMS.Substring(delimPos + 2, OSBOXPARAMS.Length - delimPos - 3); // assumming path is quoted

            // Waiting until injection is done
            injectionDone.WaitOne();

            AppDomainSetup ads = new AppDomainSetup();

            ads.ApplicationBase   = System.Environment.CurrentDirectory;
            ads.ConfigurationFile = assemblyPath + ".config";

            AppDomain ad2 = AppDomain.CreateDomain("AD #2", null, ads);

//            Assembly title = Assembly.LoadFile(assemblyPath);
            // Removing first item from the list of arguments
//            args = args.Where((val, idx) => idx > 1).ToArray();
            // System.Windows.Forms.MessageBox.Show("before");
            ad2.ExecuteAssembly(assemblyPath, args);
            AppDomain.Unload(ad2);

/*            object[] parameters = new object[0];
 *          if (title.EntryPoint.GetParameters().Length > 0)
 *          {
 *              parameters = new object[] { args };
 *          }
 *          title.EntryPoint.Invoke(null, parameters);
 */
        }
Пример #7
0
        public void ApplicationInitialise(string txtAppPath, string txtAppParam, PermissionSet permSet)
        {
            string appFilePath = Path.GetDirectoryName(txtAppPath);

            string[] appFileParam    = txtAppParam.Split(' ');
            string   appAssemblyName = Path.GetFileNameWithoutExtension(txtAppPath);

            // Application Domain Setup
            AppDomainSetup adSetup = new AppDomainSetup();

            adSetup.ApplicationBase = appFilePath;

            // Strong Name using 'Sandboxer_Key.snk'
            StrongName fullTrustAssembly = typeof(Sandboxer).Assembly.Evidence.GetHostEvidence <StrongName>();

            // Create Application Domain with a random 'ID' value so not all sandbox domains are the same
            Random    rnd       = new Random();
            AppDomain newDomain = AppDomain.CreateDomain("Sandbox" + rnd.Next().ToString(), null, adSetup, permSet, fullTrustAssembly);

            // Object handle
            ObjectHandle handle = Activator.CreateInstanceFrom(
                newDomain,
                typeof(Sandboxer).Assembly.ManifestModule.FullyQualifiedName,
                typeof(Sandboxer).FullName);

            // Execute Application code
            Sandboxer newDomainInstance = (Sandboxer)handle.Unwrap();

            Console.WriteLine("--- {0} STARTED ---", appAssemblyName);
            newDomain.ExecuteAssembly(txtAppPath, appFileParam);
            Console.WriteLine("--- {0} FINISHED ---\n", appAssemblyName);
        }
Пример #8
0
        private static Thread RunApp(FileInfo file, Thread oldthread)
        {
            string persistenceData = null;

            if (clientAppDomain != null)
            {
                clientAppDomain.DoCallBack(() => Application.Exit());
                persistenceData = clientAppDomain.GetData(PERSISTENCE_KEY) as string;
                AppDomain.Unload(clientAppDomain);
                oldthread.Join();
            }

            var ads = new AppDomainSetup();

            ads.ApplicationBase   = file.DirectoryName;
            ads.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
            clientAppDomain       = AppDomain.CreateDomain(file.FullName, null, ads);
            clientAppDomain.SetData(PERSISTENCE_KEY, persistenceData);

            waitable.Reset();

            var thread = new Thread(
                () => { try { clientAppDomain.ExecuteAssembly(file.FullName); } catch (AppDomainUnloadedException) { } finally { waitable.Set(); } });

            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();

            file.Refresh();
            lastModified = file.LastWriteTime;

            return(thread);
        }
Пример #9
0
        /// <summary>
        /// To install/uninstall the service, type: "Mod.ServiceHost.exe -Install [-u]"
        /// </summary>
        /// <returns>Win32 exit code.</returns>
        private int RunInstall()
        {
            var win32Params = Environment.GetCommandLineArgs();

            var serviceParams = new string[win32Params.Length - 1];

            //    Get the full path to the running assembly
            Assembly module = System.Reflection.Assembly.GetEntryAssembly();

            serviceParams[0] = module.Location;

            Array.Copy(win32Params, 2, serviceParams, 1, serviceParams.Length - 1);

            //    Create app domain so service installer runs isolated
            AppDomain srvInstallDomain = AppDomain.CreateDomain("ServiceInstallation");

            //    Obtain folder where .NET is installed: find mscorlib.dll which holds System.Object
            Type   objectType   = typeof(object);
            String mscorlibPath = objectType.Assembly.Location;

            //    Construct service installation command line
            var cmdLine = mscorlibPath.Substring(0, mscorlibPath.LastIndexOf("\\", System.StringComparison.Ordinal));

            cmdLine += "\\InstallUtil.exe";

            //    Run service installation in isolated domain
            return(srvInstallDomain.ExecuteAssembly(cmdLine, serviceParams));
        }
Пример #10
0
        void AppDomainSecurity(AppDomain appDomain, IPrincipal principal)   // Noncompliant, IPrincipal parameter, see another section with tests
        {
            appDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal); // Noncompliant
//          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            appDomain.SetThreadPrincipal(principal);                        // Noncompliant
            appDomain.ExecuteAssembly("");                                  // Compliant, not one of the tracked methods
        }
        static void Main(string[] args)
        {
            // Create a new application domain.
            AppDomain domain = System.AppDomain.CreateDomain("MyDomain");

            // Create a new AppDomain PolicyLevel.
            PolicyLevel polLevel = PolicyLevel.CreateAppDomainLevel();
            // Create a new, empty permission set.
            PermissionSet permSet = new PermissionSet(PermissionState.None);

            // Add permission to execute code to the permission set.
            permSet.AddPermission
                (new SecurityPermission(SecurityPermissionFlag.Execution));
            // Give the policy level's root code group a new policy statement based
            // on the new permission set.
            polLevel.RootCodeGroup.PolicyStatement = new PolicyStatement(permSet);
            // Give the new policy level to the application domain.
            domain.SetAppDomainPolicy(polLevel);

            // Try to execute the assembly.
            try
            {
                // This will throw a PolicyException if the executable tries to
                // access any resources like file I/O or tries to create a window.
                domain.ExecuteAssembly("Assemblies\\MyWindowsExe.exe");
            }
            catch (PolicyException e)
            {
                Console.WriteLine("PolicyException: {0}", e.Message);
            }

            AppDomain.Unload(domain);
        }
Пример #12
0
        static void Main(params string[] args)
        {
            var localAppFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

            var appDirectory = Directory.CreateDirectory(Path.Combine(localAppFolder, "SPM"));

            var cachePath  = Path.Combine(appDirectory.FullName, "assemblyCache");
            var config     = Path.Combine(appDirectory.FullName, "App", $"{spmExecutableName}.exe.config");
            var executable = Path.Combine(appDirectory.FullName, "App", $"{spmExecutableName}.exe");

            AppDomainSetup setup = new AppDomainSetup
            {
                ApplicationName   = "SPM",
                ShadowCopyFiles   = "true",
                CachePath         = cachePath,
                ConfigurationFile = config
            };

            AppDomain domain = AppDomain.CreateDomain(
                "SPM",
                AppDomain.CurrentDomain.Evidence,
                setup);

            domain.ExecuteAssembly(executable, args);

            AppDomain.Unload(domain);
        }
Пример #13
0
        public static void Main(string[] args)
        {
            // For the purpose of this example, if this assembly is executing
            // in an AppDomain with the friendly name "NewAppDomain", do not
            // create a new AppDomain. This avoids an infinite loop of
            // AppDomain creation.

            if (AppDomain.CurrentDomain.FriendlyName != "NewAppDomain")
            {
                // Create a new application domain.
                AppDomain domain = AppDomain.CreateDomain("NewAppDomain");

                // Execute this assembly in the new application domain and
                // pass the array of command-line arguments.
                domain.ExecuteAssembly("Recipe03-06.exe", args);
            }

            // Display the command-line arguments to the screen prefixed with
            // the friendly name of the AppDomain.
            foreach (string s in args)
            {
                Console.WriteLine(AppDomain.CurrentDomain.FriendlyName + " : " + s);
            }

            // Wait to continue.
            if (AppDomain.CurrentDomain.FriendlyName != "NewAppDomain")
            {
                Console.WriteLine("\nMain method complete. Press Enter.");
                Console.ReadLine();
            }
        }
        public override void LoadServer(string filename)
        {
            if (appDomain != null)
            {
                throw new ApplicationException("Server is already loaded");
            }

            appDomain = AppDomain.CreateDomain(Utils.RandomName(15, 20));
            thread    = new Thread(new ThreadStart(() => {
                try {
                    appDomain.ExecuteAssembly(filename, null, new string[] {
                        ((int)serviceType).ToString(), ipcName, ipcUri
                    });
                }
                catch (NullReferenceException) {
                    // Here if appDomain was set to null by Dispose() before this thread started
                }
                catch (AppDomainUnloadedException) {
                    // Here if it was unloaded by Dispose()
                }
                UnloadAppDomain(appDomain);
                appDomain = null;
            }));
            thread.Start();
        }
Пример #15
0
 internal void StartFieldWorksThread()
 {
     m_FieldWorksDomain = AppDomain.CreateDomain("Running FieldWorks Domain");
     GetFieldWorksInfo().PretendNotRunningUnitTests();
     // FIXME: use FwAppArgs.kProject and FwAppArgs.kApp
     m_FieldWorksDomain.ExecuteAssembly(typeof(FieldWorks).Assembly.Location, null, new string[] { "-app", App, "-db", Db });
 }
Пример #16
0
        static int RunInAppDomain(string[] Arguments)
        {
            // Create application domain setup information.
            AppDomainSetup Domaininfo = new AppDomainSetup();

            Domaininfo.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            Domaininfo.ShadowCopyFiles = "true";

            // Create the application domain.
            AppDomain Domain = AppDomain.CreateDomain("AutomationTool", AppDomain.CurrentDomain.Evidence, Domaininfo);
            // Execute assembly and pass through command line
            string UATExecutable = Path.Combine(Domaininfo.ApplicationBase, "AutomationTool.exe");
            // Default exit code in case UAT does not even start, otherwise we always return UAT's exit code.
            int ExitCode = 193;

            try
            {
                ExitCode = Domain.ExecuteAssembly(UATExecutable, Arguments);
                // Unload the application domain.
                AppDomain.Unload(Domain);
            }
            catch (Exception Ex)
            {
                Console.WriteLine(Ex.Message);
                Console.WriteLine(Ex.StackTrace);

                // We want to terminate the launcher process regardless of any crash dialogs, threads, etc
                Environment.Exit(ExitCode);
            }

            return(ExitCode);
        }
Пример #17
0
        /// <summary>
        /// The main entry point to the console application.
        /// </summary>
        /// <param name="args">The command-line arguments.</param>
        /// <returns><code>0</code> if the application ran successfully with no errors, otherwise <code>1</code>.</returns>
        public static async Task <int> Main(string[] args)
        {
            var debug = IsDebug();

            if (debug)
            {
                Debugger.Launch();
            }

            // Parse command-line arguments
            if (!TryParseArguments(args, out (Dictionary <string, string> Options, FileInfo MSBuildExeFilePath, string EntryProjectFilePath, Dictionary <string, string> MSBuildGlobalProperties)arguments))
            {
                return(1);
            }

            // Enable MSBuild feature flags
            MSBuildFeatureFlags.MSBuildExeFilePath           = arguments.MSBuildExeFilePath.FullName;
            MSBuildFeatureFlags.EnableCacheFileEnumerations  = true;
            MSBuildFeatureFlags.LoadAllFilesAsReadonly       = true;
            MSBuildFeatureFlags.SkipEagerWildcardEvaluations = true;
#if NETFRAMEWORK
            if (AppDomain.CurrentDomain.IsDefaultAppDomain())
            {
                // MSBuild.exe.config has binding redirects that change from time to time and its very hard to make sure that NuGet.Build.Tasks.Console.exe.config is correct.
                // It also can be different per instance of Visual Studio so when running unit tests it always needs to match that instance of MSBuild
                // The code below runs this EXE in an AppDomain as if its MSBuild.exe so the assembly search location is next to MSBuild.exe and all binding redirects are used
                // allowing this process to evaluate MSBuild projects as if it is MSBuild.exe
                var thisAssembly = Assembly.GetExecutingAssembly();

                AppDomain appDomain = AppDomain.CreateDomain(
                    thisAssembly.FullName,
                    securityInfo: null,
                    info: new AppDomainSetup
                {
                    ApplicationBase   = arguments.MSBuildExeFilePath.DirectoryName,
                    ConfigurationFile = Path.Combine(arguments.MSBuildExeFilePath.DirectoryName, "MSBuild.exe.config")
                });

                return(appDomain
                       .ExecuteAssembly(
                           thisAssembly.Location,
                           args));
            }
#endif

            // Check whether the ask is to generate the restore graph file.
            if (MSBuildStaticGraphRestore.IsOptionTrue("GenerateRestoreGraphFile", arguments.Options))
            {
                using (var dependencyGraphSpecGenerator = new MSBuildStaticGraphRestore(debug: debug))
                {
                    return(dependencyGraphSpecGenerator.WriteDependencyGraphSpec(arguments.EntryProjectFilePath, arguments.MSBuildGlobalProperties, arguments.Options) ? 0 : 1);
                }
            }

            // Otherwise run restore!
            using (var dependencyGraphSpecGenerator = new MSBuildStaticGraphRestore(debug: debug))
            {
                return(await dependencyGraphSpecGenerator.RestoreAsync(arguments.EntryProjectFilePath, arguments.MSBuildGlobalProperties, arguments.Options) ? 0 : 1);
            }
        }
Пример #18
0
        static RunResult testWithAppDomain(String path, String assemblyName)
        {
            AppDomain domain = NewDomain();

            try {
                domain.ExecuteAssembly(path);
                return(RunResult.valid);
            } catch (InvalidProgramException) {
                return(RunResult.invalid);
            } catch (FileLoadException) {
                return(RunResult.invalid);
            } catch (VerificationException) {
                return(RunResult.unverifiable);
            } catch (TypeInitializationException ve) {
                if (ve.InnerException is VerificationException)
                {
                    return(RunResult.unverifiable);
                }
                Console.WriteLine("Warning: test {0} thrown exception: {1} ", assemblyName, ve.InnerException);
                return(RunResult.invalid);
            } catch (MissingMemberException) {
                return(RunResult.invalid);
            } catch (MemberAccessException) {
                return(RunResult.unverifiable);
            } catch (TypeLoadException) {
                return(RunResult.invalid);
            } catch (BadImageFormatException) {
                return(RunResult.invalid);
            } catch (Exception e) {
                Console.WriteLine("Warning: test {0} thrown exception {1}", assemblyName, e);
                return(RunResult.valid);
            } finally {
                AppDomain.Unload(domain);
            }
        }
Пример #19
0
        public object ExecuteMothodEx(string actionName, string baseDirectory, IntPtr hWnd, string methodName = "Main")
        {
            object result = null;
            var    setup  = new AppDomainSetup();

            setup.ApplicationBase = baseDirectory;
            AppDomain _appDomain = AppDomain.CreateDomain(actionName, null, setup);

            try
            {
                var args     = new string[] { actionName, methodName };
                var location = typeof(CSharpProxy.ProxyObject).Assembly.Location;
                CSharpProxy.ProxyObject po = (CSharpProxy.ProxyObject)_appDomain.CreateInstanceFromAndUnwrap(location, typeof(CSharpProxy.ProxyObject).FullName);
                po.WindowPH = hWnd;
                result      = _appDomain.ExecuteAssembly(Path.Combine(baseDirectory, "CSharpEntry.exe"), args);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                AppDomain.Unload(_appDomain);
            }
            return(result);
        }
Пример #20
0
        private static void DataReceived(object sender, PacketReceivedEventArgs e)
        {
            Console.WriteLine($"#Conduit:\tReceived { e.Packet.Data?.Length } bytes.");

            switch (e.Packet.PacketType)
            {
            case ConduitPacketType.Print:
                Console.WriteLine("#Component:\n->\t" + Encoding.Default.GetString(e.Packet.Data));

                break;

            case ConduitPacketType.Execute:
                Console.WriteLine($"#Component:\tExecuting assembly.");

                var path = Encoding.Default.GetString(e.Packet.Data);

                ScriptDomain = AppDomain.CreateDomain("ScriptDomain");

                ScriptDomain.ExecuteAssembly(path);

                break;

            case ConduitPacketType.Terminate:
                Console.WriteLine($"#Component:\tAborting running assembly.");

                AppDomain.Unload(ScriptDomain);

                break;
            }
        }
Пример #21
0
        internal static int ExecuteNUnitTestProjectSplitter(params string[] rules)
        {
            //Assembly assembly = typeof( NUnitTestProjectSplitter.Program ).Assembly;
            string   path     = Path.Combine(TestContext.CurrentContext.TestDirectory, "NUnitTestProjectSplitter.exe");
            Assembly assembly = Assembly.LoadFile(path);

            AppDomain appDomain = AppDomain.CreateDomain(
                friendlyName: TestContext.CurrentContext.Test.Name,
                securityInfo: AppDomain.CurrentDomain.Evidence,
                info: new AppDomainSetup {
                ApplicationBase = Path.GetDirectoryName(assembly.Location)
            }
                );

            try {
                var arguments = new[] {
                    "--inputNUnitProject",
                    "NUnitTestProjects.nunit",
                    "--assembliesPath",
                    TestAssembliesPath,
                    "--splitRules",
                    string.Join(";", rules)
                };

                int exitCode = appDomain.ExecuteAssembly(assembly.CodeBase, arguments);
                return(exitCode);
            } finally {
                AppDomain.Unload(appDomain);
            }
        }
Пример #22
0
        /// <summary>
        /// Description:
        ///     This will check the plug-in repository and get the dll's which have the
        ///     implementation of IMFServicePlugin.
        /// </summary>
        /// <returns>Returns the valid assemblies.</returns>
        private static string[] GetAssemblies()
        {
            string[] validAssemblies = null;

            AppDomainSetup oDomainSetup = new AppDomainSetup();

            oDomainSetup.ApplicationBase   = AppDomain.CurrentDomain.BaseDirectory;
            oDomainSetup.ConfigurationFile = AppDomain.CurrentDomain.BaseDirectory + @"\MFPluggerService.exe.config";

            // This block will create an application domain, execute the MFAssemblyValidator assembly
            // and get the name of valid assemblies from repository.
            if (AppDomain.CurrentDomain.FriendlyName != "AssemblyValidatorDomain")
            {
                AppDomain oAppDomain = AppDomain.CreateDomain("AssemblyValidatorDomain", null, oDomainSetup);

                string pluginsPath = ServiceStartPath + "\\" + ConfigurationManager.AppSettings["PluginsFolderName"];

                // Execute the MFAssemblyValidator.exe file.
                oAppDomain.ExecuteAssembly(AppDomain.CurrentDomain.BaseDirectory + @"\MFAssemblyValidator.exe", null,
                                           Directory.GetFiles(pluginsPath, "*.dll"));

                validAssemblies = (string[])oAppDomain.GetData("AssemblyNames");

                AppDomain.Unload(oAppDomain);
            }

            return(validAssemblies);
        }
Пример #23
0
        private Thread PrepareThread()
        {
            Thread t = new Thread(() => {
                string appPath       = Path.Combine(_defaultBasePath, AppName);
                AppDomainSetup setup = new AppDomainSetup()
                {
                    ApplicationName = AppName
                };
                setup.ShadowCopyFiles = ShadowCopyFiles.ToString();
                setup.ApplicationBase = appPath;
                if (ShadowCopyFiles == true)
                {
                    setup.CachePath = Path.Combine(_shadowCopiesDirectory, AppName);
                }
                _appDomain = AppDomain.CreateDomain(AppDomainName, null, setup);
                _appDomain.ExecuteAssembly(_appExecutable);

                _state = ApplicationState.FINISHED;
                TerminatedApplicationHandler handler = OnTerminatedApplication;
                if (handler != null)
                {
                    handler(this, EventArgs.Empty);
                }
            });

            return(t);
        }
Пример #24
0
        private void toolStripButton3_Click(object sender, EventArgs e)
        {
#if DEBUG
            AppDomain domain = AppDomain.CreateDomain("Game Creator Game");
            CreateExecutable("game.exe");
#else
            CreateExecutable("game.exe");
#endif
#if !DEBUG
            System.Diagnostics.ProcessStartInfo psi = new System.Diagnostics.ProcessStartInfo("game.exe");
            psi.RedirectStandardError = true;
            psi.UseShellExecute       = false; // So we can redirect StandardError
            System.Diagnostics.Process p = System.Diagnostics.Process.Start(psi);
#endif
            FormWindowState ws = WindowState;
            WindowState = FormWindowState.Minimized;
#if DEBUG
            domain.ExecuteAssembly("game.exe");
            AppDomain.Unload(domain);
#else
            p.WaitForExit();
#endif
            WindowState = ws;
#if !DEBUG
            string err = p.StandardError.ReadToEnd();
            if (!string.IsNullOrEmpty(err))
            {
                MessageBox.Show(string.Format("The game exited with errors:\n{0}", err), "Game Creator IDE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
#endif
        }
Пример #25
0
        static void Main()
        {
            Console.WriteLine(AppDomain.CurrentDomain.FriendlyName);

            // Create a new AppDoamin
            AppDomain ad = AppDomain.CreateDomain("Playground Domain");

            // Register domain event handlers
            ad.AssemblyLoad += new AssemblyLoadEventHandler(AssemblyLoadHandler);
            ad.DomainUnload += new EventHandler(DomainUnloadHandler);

            // Exchange data between AppDomains
            ad.SetData("Creator", AppDomain.CurrentDomain);

            // Load and execute assembly in domain
            ad.ExecuteAssembly("Playground.exe");

            // Execute some code in a different AppDomain
            CrossAppDomainDelegate cadd = new CrossAppDomainDelegate(CrossAppDomainCallback);

            ad.DoCallBack(cadd);

            // Create object in another AppDomain
            string   path = Path.Combine(Directory.GetCurrentDirectory(), "DomainMasterSample.exe");
            Assembly a    = Assembly.LoadFile(path);

            ad.Load(a.GetName());
            AppDomainExplorer ade = ad.CreateInstanceAndUnwrap(a.GetName().FullName, "DomainMasterSample.AppDomainExplorer") as AppDomainExplorer;

            ade.Explore();

            // Unload the domain
            AppDomain.Unload(ad);
            Console.ReadLine();
        }
Пример #26
0
        static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //Set up your new app domain, setting ShadowCopyFiles to true so that you can replace
            // the worker while running
            AppDomainSetup domaininfo = new AppDomainSetup();

            domaininfo.ApplicationBase = Environment.CurrentDirectory;
            domaininfo.ShadowCopyFiles = "true";

            // Create the application domain.
            _domain = AppDomain.CreateDomain("MyDomain", null, domaininfo);

            while (true)
            {
                //Get your foreman running
                _domain.ExecuteAssembly("Foreman.exe");
                //take a short nap
                Thread.Sleep(new TimeSpan(0, 0, 1));
                //check to see if there is a pending cancelation of this thread, and stop if there is
                if (_backgroundWorker.CancellationPending)
                {
                    break;
                }
            }
        }
Пример #27
0
        public static void StartOmniEve()
        {
            try
            {
                Logging.Log("OmniEveLoader", "------------------------------------------------------", Logging.Debug);
                Logging.Log("OmniEveLoader", "------------------------------------------------------", Logging.Debug);
                Logging.Log("OmniEveLoader", "Main._pathToOmniEveEXE [" + Main._pathToOmniEveEXE + "]", Logging.Debug);
                Logging.Log("OmniEveLoader", "------------------------------------------------------", Logging.Debug);
                Logging.Log("OmniEveLoader", "------------------------------------------------------", Logging.Debug);

                AppDomain OmniEvesAppDomain = null;

                if (EnumAppDomains().All(i => i.FriendlyName != Main._appDomainNameToUse))
                {
                    // Create a new AppDomain (what happens if this AppDomain already exists!?!)
                    OmniEvesAppDomain = System.AppDomain.CreateDomain(Main._appDomainNameToUse);
                    Logging.Log("EXEBootStrapper", "AppDomain [" + Main._appDomainNameToUse + "] created", Logging.White);
                }
                else
                {
                    OmniEvesAppDomain = EnumAppDomains().First(i => i.FriendlyName == Main._appDomainNameToUse);
                    Logging.Log("EXEBootStrapper", "AppDomain [" + Main._appDomainNameToUse + "] already exists, reusing.", Logging.White);
                }


                // Load the assembly and call the default entry point:
                try
                {
                    OmniEvesAppDomain.ExecuteAssembly(Main._pathToOmniEveEXE, new string[] { "-i=" + Main._OmniEveDLLSettingsINI, "-d=" + Logging.ConsoleLogPath, "-f=" + Logging.ConsoleLogFile, "-s=" + Logging.SaveConsoleLog });
                }
                catch (AppDomainUnloadedException)
                {
                    Logging.Log("EXEBootStrapper", "AppDomain [" + Main._appDomainNameToUse + "] unloaded", Logging.White);
                }

                Logging.Log("EXEBootStrapper", "ExecuteAssembly [" + Main._pathToOmniEveEXE + "] finished", Logging.White);
                //Main.UnthawEVEProcess = true;

                // Create an instance of MarshalbyRefType in the second AppDomain.
                // A proxy to the object is returned.
                CrossDomainTest mbrt =
                    (CrossDomainTest)OmniEvesAppDomain.CreateInstanceAndUnwrap(
                        Main._pathToOmniEveEXE,
                        typeof(CrossDomainTest).FullName
                        );

                // Call a method on the object via the proxy, passing the
                // default AppDomain's friendly name in as a parameter.
                mbrt.SomeMethod(Main._appDomainNameToUse);
            }
            catch (Exception ex)
            {
                Logging.Log("EXEBootStrapper", "exception [" + ex + "]", Logging.White);
            }
            finally
            {
                Logging.Log("EXEBootStrapper", "done.", Logging.White);
            }
        }
Пример #28
0
        static void Main(string[] args)
        {
            foreach (Process i in Process.GetProcesses())
            {
                Console.WriteLine($"Имя процесса : {i.ProcessName} | ID процесса : {i.Id}");
                Console.WriteLine();
            }


            AppDomain domain = AppDomain.CurrentDomain;

            Console.WriteLine($"Имя домена : {domain.FriendlyName}");
            Console.WriteLine($"Базовый каталог : {domain.BaseDirectory}");
            Console.WriteLine($"Детали конфигурации : {domain.SetupInformation}");
            Assembly[] assemblies = domain.GetAssemblies();
            foreach (Assembly i in assemblies)
            {
                Console.WriteLine(i.GetName());
            }



            AppDomain newD = AppDomain.CreateDomain("MyDomen");

            newD.ExecuteAssembly(@"D:\OOP\Lab_14\Lab_14\bin\Debug\netcoreapp3.1\Lab_14.exe");
            AppDomain.Unload(newD);



            Console.WriteLine("___________________");
            Console.WriteLine("Введите число n :");
            int    n       = Int32.Parse(Console.ReadLine());
            Thread thread1 = new Thread(() => Number(n));

            thread1.Start();
            Thread t = Thread.CurrentThread;

            t.Name = "Поток №1";
            Console.WriteLine($"Имя потока : {t.Name}");
            Console.WriteLine($"Приотирет потока : {t.Priority}");
            Console.WriteLine($"ID потока : {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(2000);
            Console.WriteLine($"Текущее состояние потока : {Thread.CurrentThread.ThreadState}");
            Console.WriteLine($"Текущее состояние потока 1 : {thread1.ThreadState}");


            Thread thread2 = new Thread(() => EvenNumber(n));

            thread2.Start();


            Thread thread3 = new Thread(() => UnevenNumber(n));

            thread3.Start();
            TimerCallback tm    = new TimerCallback(EndThis);
            Timer         timer = new Timer(tm, 0, 0, 2000);

            Console.ReadKey();
        }
Пример #29
0
        static void Main(string[] args)
        {
            Console.WriteLine("Сейчас будем запускать другую сборку в нашем процессе");
            AppDomain ad = AppDomain.CreateDomain("Мой домен");

            ad.ExecuteAssembly(@"F:\c#\Thread\DomainTest\bin\Release\DomainTest.exe");
            Console.ReadLine();
        }
Пример #30
0
    static void Main(string[] args)
    {
        Console.WriteLine("I'm running on the domain: {0}", AppDomain.CurrentDomain.FriendlyName);
        AppDomain second = AppDomain.CreateDomain("Second.exe");

        second.ExecuteAssembly("Second.exe");
        Console.WriteLine("First domain ending ...");
    }