Выгрузка DLL AppDomain.Unload

        private string ScriptsDirectory = System.Environment.CurrentDirectory+"\\Scripts";
        private const string CompiledScriptsAssemblyName = "Scripts.dll";
        public static bool SeconButtonClick = false;
 
        private void StartButton_Click(object sender, EventArgs e)
        {
            IScriptableComponent component = new DummyComponent();
 
            var compiledAssemblyPath = Path.Combine(Environment.CurrentDirectory, ScriptsDirectory, CompiledScriptsAssemblyName);
            var scriptFiles = Directory.EnumerateFiles(ScriptsDirectory, "*.cs", SearchOption.AllDirectories).ToArray();
 
            var scriptAssembly = Helper.CompileAssembly(scriptFiles, compiledAssemblyPath);
 
            var scriptTypes = Helper.GetTypesImplementingInterface(scriptAssembly, typeof(IScript));
 
            foreach (var scriptType in scriptTypes)
            {
                var script = (IScript)Activator.CreateInstance(scriptType);
                script.Run(component);
            }
        }

 public static Assembly CompileAssembly(string[] sourceFiles, string outputAssemblyPath)
        {
 
            var codeProvider = new CSharpCodeProvider();
 
            var compilerParameters = new CompilerParameters
            {
                GenerateExecutable = false,    
                GenerateInMemory = false,      
                IncludeDebugInformation = false, 
                OutputAssembly = outputAssemblyPath
            };
 
            compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
 
            var result = codeProvider.CompileAssemblyFromFile(compilerParameters, sourceFiles);
 
            if (result.Errors.HasErrors) throw new Exception("Assembly compilation failed.");
            
            return result.CompiledAssembly;
        }
 
 
        public static List<Type> GetTypesImplementingInterface(Assembly assembly, Type interfaceType)
        {
            if (!interfaceType.IsInterface) throw new ArgumentException("Not an interface.", "interfaceType");
 
            return assembly.GetTypes()
                           .Where(t => interfaceType.IsAssignableFrom(t))
                           .ToList();
        }

string source = System.IO.File.ReadAllText("Program.cs");
 
            var provider_options = new Dictionary<string, string>
                         {
                             {"CompilerVersion","v3.5"}
                         };
 
            var provider = new Microsoft.CSharp.CSharpCodeProvider(provider_options);
            var compiler_params = new System.CodeDom.Compiler.CompilerParameters();
            string outfile = "E:\\Matrix.EXE";
            compiler_params.OutputAssembly = outfile;
            compiler_params.GenerateExecutable = true;
            var results = provider.CompileAssemblyFromSource(compiler_params, source);
            Console.WriteLine("Output file: {0}", outfile);
            Console.WriteLine("Number of Errors: {0}", results.Errors.Count);
            foreach (System.CodeDom.Compiler.CompilerError err in results.Errors)
            {
                Console.WriteLine("ERROR {0}", err.ErrorText);
            }
            Console.ReadKey();

var compiledAssemblyPath = Path.Combine(Environment.CurrentDirectory, ScriptsDirectory, CompiledScriptsAssemblyName);
var scriptFiles = Directory.EnumerateFiles(ScriptsDirectory, "*.cs", SearchOption.AllDirectories).ToArray();

 public static Assembly CompileAssembly(string[] sourceFiles, string outputAssemblyPath)
        {
 
            var codeProvider = new CSharpCodeProvider();
 
            var compilerParameters = new CompilerParameters
            {
                GenerateExecutable = false,     // Make a DLL
                GenerateInMemory = false,       // Explicitly save it to path specified by compilerParameters.OutputAssembly
                IncludeDebugInformation = false, // Enable debugging - generate .pdb
                OutputAssembly = outputAssemblyPath
            };
 
            // !! This is important: It adds the THIS project as a reference to the compiled dll to expose the public interfaces (as you would add it in the visual studio)
            compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
 
            var result = codeProvider.CompileAssemblyFromFile(compilerParameters, sourceFiles); // Compile
 
            if (result.Errors.HasErrors)
                throw new Exception("Assembly compilation failed.");
            
            return result.CompiledAssembly;
        }

        public static List<Type> GetTypesImplementingInterface(Assembly assembly, Type interfaceType)
        {
            if (!interfaceType.IsInterface) throw new ArgumentException("Not an interface.", "interfaceType");
 
            return assembly.GetTypes()
                           .Where(t => interfaceType.IsAssignableFrom(t))
                           .ToList();
        }

 var scriptAssembly = Helper.CompileAssembly(scriptFiles, compiledAssemblyPath);
 
            // Find all types that implement the IScript interface in the compiled assembly
            var scriptTypes = Helper.GetTypesImplementingInterface(scriptAssembly, typeof(IScript));
 
            foreach (var scriptType in scriptTypes)
            {
                // Creates instances of type and pass component to the constructor
                var script = (IScript)Activator.CreateInstance(scriptType);
                script.Run(component);
            }

public static object Call(string dll, string typename, string method, params object[] parameters)
    {
        AppDomain dom = AppDomain.CreateDomain("Volatile");
        Loader ld = (Loader)dom.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(Loader).FullName);
        object result = ld.CallInternal(dll, typename, method, parameters);
        AppDomain.Unload(dom);
        File.Delete(dll);
        return result;
    }

 public class RemoteLoader : MarshalByRefObject
        {
            public void LoadAndExecute(string assemblyName)
            {
                Assembly pluginAassembly = AppDomain.CurrentDomain.Load(assemblyName);
 
                foreach (Type type in pluginAassembly.GetTypes())
                {
                    if (type.GetInterface("IScript") != null)
                    {
                        IScriptableComponent component = new DummyComponent();
                        var instance = (IScript)Activator.CreateInstance(type, null, null);
                        instance.Run(component);
                    }
                }
            }
        }

 private void StartButton_Click(object sender, EventArgs e)
        {
            
            // This is exposed to the scripts
           // IScriptableComponent component = new DummyComponent();
            
            var compiledAssemblyPath = Path.Combine(Environment.CurrentDirectory, ScriptsDirectory, CompiledScriptsAssemblyName);
           
            var scriptFiles = Directory.EnumerateFiles(ScriptsDirectory, "*.cs", SearchOption.AllDirectories).ToArray();
 
            var scriptAssembly = Helper.CompileAssembly(scriptFiles, compiledAssemblyPath);
            
            AppDomain appDomainPluginB = AppDomain.CreateDomain("appDomainPluginB");
 
            RemoteLoader loader = (RemoteLoader)appDomainPluginB.CreateInstanceAndUnwrap(
               scriptAssembly.FullName,
                "Scripts.MyCustomScript");
 
            loader.LoadAndExecute(CompiledScriptsAssemblyName);
            AppDomain.Unload(appDomainPluginB);
 
        }