C# StandardKernel.GetAll方法代碼示例

 public IEnumerable<IValidationDefinition> GetModules()
 {
     IKernel kernel = new StandardKernel();
     kernel.Load(Assembly.GetExecutingAssembly());
     var modules = kernel.GetAll<IValidationDefinition>().ToList();
     return modules;
 }

        static void Main(string[] args)
        {
            var kernel = new StandardKernel();
            BuildDependencies(kernel);

            var commandReaders = kernel.GetAll<ICommandReader>().ToList();

            bool exit = false;
            while (!exit)
            {
                var command = Console.ReadLine();
                if (command == "exit" || command == "quit")
                {
                    exit = true;
                    continue;
                }

                foreach (var commandReader in commandReaders)
                {
                    if (!commandReader.Validate(command))
                    {
                        continue;
                    }

                    commandReader.Process(command);
                    break;
                }
            }
        }

        public static void Configure(HttpConfiguration config)
        {
            config.Filters.Add(new ValidationActionFilter());

            var kernel = new StandardKernel();
            kernel.Bind<ISlechRepository>().ToConstant(new InitialData());
            config.ServiceResolver.SetResolver(
                t => kernel.TryGet(t),
                t => kernel.GetAll(t));
        }

 public MainWindow()
 {
     InitializeComponent();
     IKernel kernel = new StandardKernel();
     LibraryLoader.LoadAllBinDirectoryAssemblies();
     if (File.Exists("TypeMappings.xml"))
         kernel.Load("TypeMappings.xml");
     var plugins = kernel.GetAll<IPlugin>().ToList();
     PluginsListView.ItemsSource = plugins;
 }

        private static void LoadModules()
        {
            var kernel = new StandardKernel();
            kernel.Bind(c =>
                    c.FromAssembliesInPath("./")
                        .SelectAllClasses()
                        .InheritedFrom<IModule>()
                        .BindAllInterfaces());

            foreach (var module in kernel.GetAll<IModule>())
            {
                string name = module.GetModuleMetadata().Name;
                if (mModules.ContainsKey(name))
                {
                    throw new ArgumentException("Module with the name '{0}' already exists!", name);
                }

                mModules.Add(name, module);
            }
        }

        public static void RegisterDependenciesViaNinject(HttpConfiguration httpConfiguration)
        {
            var kernel = new StandardKernel();
            kernel.Bind<IWordRepository>().To<WordRepository>();
            kernel.Bind<IMeaningRepository>().To<MeaningRepository>();

            httpConfiguration.ServiceResolver.SetResolver(
                t => kernel.TryGet(t),
                t => kernel.GetAll(t));
        }

        static void Main(string[] args)
        {
            IKernel kernel = new StandardKernel(new OrmConfigurationModule(), new HarnessModule());

            var config = kernel.Get<IRunnerConfig>();

            List<List<ScenarioResult>> allRunResults = new List<List<ScenarioResult>>();

            for (int i = 0; i < config.NumberOfRuns; i++)
            {
                Console.WriteLine(String.Format("Starting run number {0} at {1}", i, DateTime.Now.ToShortTimeString()));
                allRunResults.Add(kernel.Get<ScenarioRunner>().Run(config.MaximumSampleSize));
            }

            var compiledResults = new List<CompiledScenarioResult>();
            foreach (var result in allRunResults[0])
            {
                var results = from set in allRunResults
                              from res in set
                              where res.ConfigurationName == result.ConfigurationName
                              where res.SampleSize == result.SampleSize
                              where res.ScenarioName == result.ScenarioName
                              where res.Technology == result.Technology
                              select res;
                compiledResults.Add(new CompiledScenarioResult
                {
                    ConfigurationName       = result.ConfigurationName,
                    SampleSize              = result.SampleSize,
                    ScenarioName            = result.ScenarioName,
                    Technology              = result.Technology,
                    MinSetupTime            = results.OrderBy(r => r.SetupTime).Take(results.Count()             - config.DiscardWorst).Min(r=>r.SetupTime),
                    AverageSetupTime        = results.OrderBy(r => r.SetupTime).Take(results.Count()             - config.DiscardWorst).Average(r => r.SetupTime),
                    MaxSetupTime            = results.OrderBy(r => r.SetupTime).Take(results.Count()             - config.DiscardWorst).Max(r => r.SetupTime),
                    MinApplicationTime      = results.OrderBy(r => r.ApplicationTime).Take(results.Count()       - config.DiscardWorst).Min(r => r.ApplicationTime),
                    AverageApplicationTime  = results.OrderBy(r => r.ApplicationTime).Take(results.Count()       - config.DiscardWorst).Average(r => r.ApplicationTime),
                    MaxApplicationTime      = results.OrderBy(r => r.ApplicationTime).Take(results.Count()       - config.DiscardWorst).Max(r => r.ApplicationTime),
                    MinCommitTime           = results.OrderBy(r => r.CommitTime).Take(results.Count()            - config.DiscardWorst).Min(r => r.CommitTime),
                    AverageCommitTime       = results.OrderBy(r => r.CommitTime).Take(results.Count()            - config.DiscardWorst).Average(r => r.CommitTime),
                    MaxCommitTime           = results.OrderBy(r => r.CommitTime).Take(results.Count()            - config.DiscardWorst).Max(r => r.CommitTime),
                    Status                  = results.OrderByDescending(r => (int) r.Status.State).Select(r=> r.Status).FirstOrDefault() ?? new AssertionPass(),
                    MemoryUsage             = results.Count() > config.DiscardWorst + config.DiscardHighestMemory 
                                                ? results.OrderBy(r => r.MemoryUsage).Take(results.Count() - config.DiscardWorst)
                                                    .OrderByDescending(r => r.MemoryUsage).Take(results.Count() - config.DiscardWorst -config.DiscardHighestMemory).Average(r => r.MemoryUsage)
                                                : results.Average(r=>r.MemoryUsage)
                });

            }

            foreach (var formatter in kernel.GetAll<IResultFormatter<CompiledScenarioResult>>())
            {
                formatter.FormatResults(compiledResults);
            }

            Console.ReadLine();
        }

 public ThreadedPerformanceSessionControl()
 {
     InitializeComponent();
     _testUrls = new List<string>();
     IKernel kernel = new StandardKernel();
     LibraryLoader.LoadAllBinDirectoryAssemblies();
     if (File.Exists("TypeMappings.xml"))
         kernel.Load("TypeMappings.xml");
     var plugins = kernel.GetAll<IThreadedPerformanceSessionTestUrlGenerator>().ToList();
     UrlGeneratorPlugins.ItemsSource = plugins.ToList();
 }

 public static void Main(string[] args)
 {
     var kernel = new StandardKernel();
     kernel.Load<TychaiaGlobalIoCModule>();
     kernel.Load<TychaiaProceduralGenerationIoCModule>();
     kernel.Load<TychaiaToolIoCModule>();
     ConsoleCommandDispatcher.DispatchCommand(
         kernel.GetAll<ConsoleCommand>(),
         args,
         Console.Out);
 }

        /// <summary>
        /// Creates the kernel that will manage your application.
        /// </summary>
        /// <returns>The created kernel.</returns>
        private static IKernel CreateKernel()
        {
            var kernel = new StandardKernel();
            kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
            kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();

            RegisterServices(kernel);

            DependencyResolver.SetResolver(t => kernel.TryGet(t), t => kernel.GetAll(t));
            GlobalConfiguration.Configuration.DependencyResolver = new NinjectDependencyResolver(kernel);

            return kernel;
        }

        public static void Configure(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute("def", "bugs/{controller}", new {controller = "Index"});

            config.Formatters.Add(new RazorHtmlMediaTypeFormatter());
            config.MessageHandlers.Add(new EtagMessageHandler());

            var kernel = new StandardKernel();
            kernel.Bind<IBugRepository>().To<StaticBugRepository>();

            config.ServiceResolver.SetResolver(t => kernel.TryGet(t), t => kernel.GetAll(t));

            AutoMapperConfig.Configure();
        }

        public void CanGetAllValidators()
        {
            IKernel kernel = new StandardKernel();
            kernel.Scan(scanner =>
            {
                scanner.From(typeof(IValidator).Assembly);
                scanner.WhereTypeInheritsFrom<IValidator>();
                scanner.BindWith<NinjectServiceToInterfaceBinder>();
            });
            var validators = kernel.GetAll<IValidator>();

            Assert.IsNotNull(validators);
            Assert.AreEqual(3, validators.Count());
        }

        public void CanFilterOutValidatorRegistrations()
        {
            IKernel kernel = new StandardKernel();
            kernel.Scan(scanner =>
            {
                scanner.From(typeof(IValidator).Assembly);
                scanner.WhereTypeInheritsFrom<IValidator>();
                // excluding the FailValidator should leave 2 of them
                scanner.Where(t => t != typeof(FailValidator));
                scanner.BindWith<NinjectServiceToInterfaceBinder>();
            });
            var validators = kernel.GetAll<IValidator>();

            Assert.IsNotNull(validators);
            Assert.AreEqual(2, validators.Count());
        }

        public static void Main(string[] args)
        {
            var kernel = new StandardKernel(new Bindings());

            new Service(args,
                   ()=> kernel.GetAll<IWindowsService>().ToArray(),
                   installationSettings: (serviceInstaller, serviceProcessInstaller) =>
                   {
                       serviceInstaller.ServiceName = "OpenSonos.LocalMusicServer.Service";
                       serviceInstaller.StartType = ServiceStartMode.Automatic;
                       serviceProcessInstaller.Account = ServiceAccount.NetworkService;
                   },
                   configureContext: x => { x.Log = Console.WriteLine; },
                   registerContainer: () => new SimpleServicesToNinject(kernel))
           .Host();
        }

        private static HttpSelfHostServer SetupWebApiServer(string url)
        {
            var ninjectKernel = new StandardKernel();
            ninjectKernel.Bind<IContactRepository>().To<InMemoryContactRepository>();

            var configuration = new HttpSelfHostConfiguration(url);
            configuration.ServiceResolver.SetResolver(
                t => ninjectKernel.TryGet(t),
                t => ninjectKernel.GetAll(t));

            configuration.Routes.MapHttpRoute(
                "Default",
                "{controller}/{id}/{ext}",
                new {id = RouteParameter.Optional, ext = RouteParameter.Optional});

            var host = new HttpSelfHostServer(configuration);

            return host;
        }