C# AssemblyLoader类代码示例

        public static void LoadPackages(Action<IPackageFacility> configuration, bool runActivators = true)
        {
            _packages.Clear();

            Diagnostics = new PackagingDiagnostics();
            var record = new PackageLoadingRecord();

            Diagnostics.LogExecution(record, () =>
            {
                var facility = new PackageFacility();
                var assemblyLoader = new AssemblyLoader(Diagnostics);
                var graph = new PackagingRuntimeGraph(Diagnostics, assemblyLoader, _packages);

                var codeLocation = findCallToLoadPackages();
                graph.PushProvenance(codeLocation);
                configuration(facility);
                facility.Configure(graph);


                graph.PopProvenance();
                graph.DiscoverAndLoadPackages(() =>
                {
                    _assemblies.Clear();
                    _assemblies.AddRange(assemblyLoader.Assemblies);
                }, runActivators);
            });

            record.Finished = DateTime.Now;

            //_packages.Clear();


        }

        public void Loader_returns_null_if_assembly_is_not_found_at_path()
        {
            var assemblyLoader = new AssemblyLoader();
            var assembly = assemblyLoader.LoadAssembly(@"c:\a\non\existent\path\assembly.dll");

            Assert.That(assembly, Is.Null);
        }

 public PluginContainerBuilder(AssemblyLoader assemblyLoader, IPluginJudge pluginJudge, IContainerFactory containerFactory, ILogger logger)
 {
     _assemblyLoader = assemblyLoader;
     _pluginJudge = pluginJudge;
     _containerFactory = containerFactory;
     _logger = logger;
 }

 /// <summary>Initialises the assembly loader.</summary>
 internal static void Init()
 {
     if (instance == null)
     {
         instance = new AssemblyLoader();
     }
 }

        public void Run()
        {
            var assemblyLoader = new AssemblyLoader(this.assemblyPath);
            var assembly = assemblyLoader.Assembly;

            var testMethodLoader = new TestMethodLoader(assembly);
            var testContainers = testMethodLoader.LoadTestMethods();
            foreach (var testContainer in testContainers)
            {
                var instance = Activator.CreateInstance(testContainer.Key);
                var testMethods = testContainer.Value;
                foreach (MethodInfo testMethod in testMethods)
                {
                    var testType = this.GetTestType(testMethod);

                    var testRunner = TestRunnerFactory.GetTestRunner(
                        testType,
                        testMethod,
                        instance);

                    testRunner.RunTest();
                    this.LogTestResult(testRunner, testMethod);
                }
            }
        }

        public void Load_NullOrEmptyPath_ReturnsNull(string path)
        {
            var subject = new AssemblyLoader(path);
            var result = subject.Load();

            Assert.AreEqual(null, result);
        }

        //parameterParsers are classes that extends from IExternalConstructor
        public ClassHierarchyImpl(string[] assemblies, Type[] parameterParsers)  
        {
            this.assemblies = assemblies;
            rootNode = NodeFactory.CreateRootPackageNode();
            loader = new AssemblyLoader(assemblies);
           
            foreach (Type p in parameterParsers) //p must be extend from IExternalConstructor
            {
                try 
                {
                    Parameterparser.AddParser(p);
                } 
                catch (BindException e)
                {
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException("Could not register parameter parsers", e), LOGGER);
                }
            }

            foreach (var a in loader.Assemblies)
            {
                foreach (var t in a.GetTypes())
                {
                    RegisterType(t);
                }
            }
        }

        public static void RunTests()
        {
            var loader = new AssemblyLoader();
            var testMethods = loader.GatherTests();

            Console.LogDateTime = true;

            foreach (var untypedTest in testMethods)
            {
                var methodInfo = (MethodInfo)untypedTest;

                try
                {
                    methodInfo.Invoke(null, null);
                    Console.WriteLine(methodInfo.DeclaringType + "." + methodInfo.Name + " - Passed.");
                }
                catch(ControlledAssertionException controlledAssertionException)
                {
                    Log(methodInfo, controlledAssertionException.Message);
                }
                catch (Exception ex)
                {
                    Log(methodInfo, "Failed", ex);
                }
            }

            Console.WriteLine("End of test run.");
        }

 public TestRunner(Logger output, AssemblyLoader assemblyLoader)
 {
     AllPassed = true;
     this.output = output;
     this.assemblyLoader = assemblyLoader;
     processor = new StepProcessor(this);
 }

        public static void Main()
        {
            var loader = new AssemblyLoader();

            var plugin = loader.LoadPlugInAppDomain("Plug.dll");

            plugin.Delay(TimeSpan.FromSeconds(2)).Subscribe(x => Console.WriteLine("Delayed: " + x));
            var isTrue = true;

            while (isTrue)
            {
                var text = Console.ReadLine();

                plugin.Push(text);

                if (string.IsNullOrEmpty(text))
                    isTrue = false;
            }

            plugin.Dispose();

            Console.WriteLine("Plugin disposed.");

            Console.ReadLine();
        }

        public OperationExecutor(
            [NotNull] CommonOptions options,
            [CanBeNull] string environment)
        {
            var projectFile = Path.Combine(Directory.GetCurrentDirectory(), Project.FileName);
            var project = ProjectReader.GetProject(projectFile);

            var projectConfiguration = options.Configuration ?? Constants.DefaultConfiguration;
            var projectFramework = options.Framework;

            var projectContext = ProjectContext.Create(project.ProjectFilePath,
                projectFramework,
                RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());

            var runtimeOutputPath = projectContext.GetOutputPaths(projectConfiguration)?.RuntimeOutputPath;
            if (!string.IsNullOrEmpty(runtimeOutputPath))
            {
                Reporter.Verbose.WriteLine(
                    ToolsCliStrings.LogDataDirectory(runtimeOutputPath));
                Environment.SetEnvironmentVariable(DataDirEnvName, runtimeOutputPath);
#if NET451
                AppDomain.CurrentDomain.SetData("DataDirectory", runtimeOutputPath);
#endif
            }

            var assemblyName = project.GetCompilerOptions(projectFramework, projectConfiguration).OutputName;
            var projectDir = project.ProjectDirectory;
            var rootNamespace = project.Name;

            var assemblyLoader = new AssemblyLoader(Assembly.Load);
            var projectAssembly = assemblyLoader.Load(assemblyName);

            _contextOperations = new LazyRef<DbContextOperations>(
                          () => new DbContextOperations(
                              new LoggerProvider(name => new ConsoleCommandLogger(name)),
                              projectAssembly,
                              projectAssembly,
                              environment,
                              projectDir));
            _databaseOperations = new LazyRef<DatabaseOperations>(
                () => new DatabaseOperations(
                    new LoggerProvider(name => new ConsoleCommandLogger(name)),
                    assemblyLoader,
                    projectAssembly,
                    environment,
                    projectDir,
                    projectDir,
                    rootNamespace));
            _migrationsOperations = new LazyRef<MigrationsOperations>(
                () => new MigrationsOperations(
                    new LoggerProvider(name => new ConsoleCommandLogger(name)),
                    projectAssembly,
                    assemblyLoader,
                    projectAssembly,
                    environment,
                    projectDir,
                    projectDir,
                    rootNamespace));
        }

 internal PackageInstaller(IFileSystem fileSystem, AssemblyLoader assemblyLoader)
 {
     _fileSystem = fileSystem;
     _assemblyLoader = assemblyLoader;
     _currentFramework = GetCurrentFramework();
     _settings = Settings.LoadDefaultSettings(fileSystem.RootPath.FullPath, null, new MachineWideSettings());
     _sourceRepositories = new SourceRepositoryProvider(_settings);
 }

 public static FrameworkAdapter Try(AssemblyLoader assemblyLoader) {
    foreach (var assemblyName in assemblyLoader.GetReferencedAssemblies()) {
       if (assemblyName.FullName.ToLower().Contains("nunit.framework,")) {
          return new NUnitAdapter();
       }
    }
    return null;
 }

 public static FrameworkAdapter Try(AssemblyLoader assemblyLoader) {
    foreach (var assemblyName in assemblyLoader.GetReferencedAssemblies()) {
       if (assemblyName.FullName.Contains("Microsoft.VisualStudio.QualityTools.UnitTestFramework,")) {
          return new MsUnitTestAdapter();
       }
    }
    return null;
 }

        public void AssemblyLoaderMustLoadTargetAssemblyFromDisk()
        {
            IAssemblyLoader loader = new AssemblyLoader();

            // The loader should return a valid assembly
            Assembly result = loader.Load(typeof(SampleClass).Assembly.Location);
            Assert.IsNotNull(result);
        }