CryEngine.Utilities.AssemblyReferenceHandler.GetRequiredAssembliesFromFiles C# (CSharp) Method

        public string[] GetRequiredAssembliesFromFiles(IEnumerable<string> scriptFilePaths)
        {
            if(scriptFilePaths == null)
                return null;

            var assemblyPaths = new List<string>();

            foreach(var scriptFilePath in scriptFilePaths)
            {
                foreach(var foundNamespace in GetNamespacesFromScriptFile(scriptFilePath))
                {
                    var assemblyPath = GetAssemblyPathFromNamespace(foundNamespace);

                    if(assemblyPath != null && !assemblyPaths.Contains(assemblyPath))
                        assemblyPaths.Add(assemblyPath);
                }
            }

            foreach(var assembly in AppDomain.CurrentDomain.GetAssemblies().Select(x => x.Location).ToArray())
            {
                if(!assemblyPaths.Contains(assembly))
                    assemblyPaths.Add(assembly);
            }

            return assemblyPaths.ToArray();
        }

        Assembly CompileFromSource(CodeDomProvider provider, string searchPattern)
        {
            var compilerParameters = new CompilerParameters();

            compilerParameters.GenerateExecutable = false;

            // Necessary for stack trace line numbers etc
            compilerParameters.IncludeDebugInformation = true;
            compilerParameters.GenerateInMemory = false;

            #if RELEASE
            if(!compilationParameters.ForceDebugInformation)
            {
                compilerParameters.GenerateInMemory = true;
                compilerParameters.IncludeDebugInformation = false;
            }
            #endif

            if(!compilerParameters.GenerateInMemory)
            {
                var assemblyPath = Path.Combine(PathUtils.TempFolder, string.Format("CompiledScripts_{0}.dll", searchPattern.Replace("*.", "")));

                if(File.Exists(assemblyPath))
                {
                    try
                    {
                        File.Delete(assemblyPath);
                    }
                    catch(Exception ex)
                    {
                        if(ex is UnauthorizedAccessException || ex is IOException)
                            assemblyPath = Path.ChangeExtension(assemblyPath, "_" + Path.GetExtension(assemblyPath));
                        else
                            throw;
                    }
                }

                compilerParameters.OutputAssembly = assemblyPath;
            }

            var scripts = new List<string>();
            var scriptsDirectory = PathUtils.ScriptsFolder;

            if(Directory.Exists(scriptsDirectory))
            {
                foreach (var script in Directory.GetFiles(scriptsDirectory, searchPattern, SearchOption.AllDirectories))
                    scripts.Add(script);
            }
            else
                Debug.LogAlways("Scripts directory could not be located");

            CompilerResults results;
            using(provider)
            {
                var referenceHandler = new AssemblyReferenceHandler();
                compilerParameters.ReferencedAssemblies.AddRange(referenceHandler.GetRequiredAssembliesFromFiles(scripts));

                results = provider.CompileAssemblyFromFile(compilerParameters, scripts.ToArray());
            }

            return ScriptCompiler.ValidateCompilation(results);
        }