C# DependencyInjectionContainer.Resolve方法代码示例

        public static void Main()
        {
            try
            {
                ThreadPoolConfiguration.Init();

                using (var container = new DependencyInjectionContainer())
                {
                    var gameApp = container.Resolve<GameApp>();
                    gameApp.Run();
                }
            }
            catch (Exception ex)
            {
                if (Debugger.IsAttached)
                {
                    Debugger.Break();
                }

                MessageBox.Show(ex.ToString(), "CubeHack", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public static void ConfigureDependencies(DependencyInjectionContainer container)
        {
            ILinqToAstoriaQueryEvaluationStrategy strategy;
            if (!container.TryResolve<ILinqToAstoriaQueryEvaluationStrategy>(out strategy))
            {
                container.Register<ILinqToAstoriaQueryEvaluationStrategy, LinqToAstoriaClrQueryEvaluationStrategy>();
                container.Register<IPrimitiveDataTypeResolver, NullPrimitiveDataTypeResolver>();
            }

            container.Register<IQueryDataSetBuilder, AstoriaQueryDataSetBuilder>();
            container.Register<IQueryRepositoryBuilder, AstoriaQueryRepositoryBuilderBase>();
            container.Register<IQueryExpressionEvaluator, LinqToAstoriaEvaluator>();
            container.Register<ILinqToAstoriaQueryResolver, LinqToAstoriaQueryResolver>();
            container.Register<ILinqToAstoriaQuerySpanGenerator, LinqToAstoriaQuerySpanGenerator>();
            container.Register<IClientQueryResultComparer, ClientQueryResultComparer>();
            container.Register<IOracleBasedDataSynchronizer, QueryDataSetSynchronizer>();
            container.Register<ILinqResultComparerContextAdapter, LinqResultComparerDataServiceContextAdapter>();
            container.Register<IQueryValueDeepCopyingVisitor, AstoriaQueryValueDeepCopyingVisitor>();
            container.Register<ISpatialClrTypeResolver, SpatialClrTypeResolver>();
            container.Register<ISpatialDataTypeDefinitionResolver, SpatialDataTypeDefinitionResolver>();

            container.RegisterCustomResolver(
                typeof(QueryRepository),
                resolver =>
                {
                    var workspace = container.Resolve<AstoriaWorkspace>();
                    if (workspace.CurrentQueryRepository == null)
                    {
                        var queryTypeLibrary = container.Resolve<QueryTypeLibrary>();
                        var queryRepositoryBuilder = container.Resolve<IQueryRepositoryBuilder>();
                        var queryRepository = queryRepositoryBuilder.CreateQueryRepository(workspace.ConceptualModel, queryTypeLibrary, workspace.DownloadedEntityContainerData);
                        workspace.CurrentQueryRepository = queryRepository;
                    }

                    return workspace.CurrentQueryRepository;
                });

            container.RegisterCustomResolver(
               typeof(IQueryDataSet),
               resolver =>
               {
                   var queryRepository = container.Resolve<QueryRepository>();
                   return queryRepository.DataSet;
               });

            container.RegisterServiceReference<IDataOracleService>(
               () =>
               {
                   var workspace = container.Resolve<AstoriaWorkspace>();
                   return workspace.OracleServiceUri;
               });

            container.RegisterCustomResolver(
                typeof(IEntitySetResolver),
                esResolver =>
                {
                    var workspace = container.Resolve<AstoriaWorkspace>();
                    return workspace.EntitySetResolver;
                });

            container.RegisterCustomResolver(
                typeof(IQueryTypeLibraryBuilder),
                queryTypeLibBuilderResolver =>
                {
                    var queryEvaluationStrategy = container.Resolve<ILinqToAstoriaQueryEvaluationStrategy>();
                    var primitiveTypeResolver = container.Resolve<IPrimitiveDataTypeResolver>();
                    var edmDataTypeResolver = container.Resolve<EdmDataTypeResolver>();
                    return new AstoriaQueryTypeLibraryBuilder(queryEvaluationStrategy, primitiveTypeResolver, edmDataTypeResolver);
                });

            container.RegisterCustomResolver(
                typeof(QueryTypeLibrary),
                queryTypeLib =>
                {
                    var workspace = container.Resolve<AstoriaWorkspace>();
                    if (workspace.CurrentQueryRepository == null)
                    {
                        var queryTypeLibraryBuilder = container.Resolve<IQueryTypeLibraryBuilder>();
                        var queryTypeLibrary = queryTypeLibraryBuilder.BuildLibraryWithoutClrTypeMapping(workspace.ConceptualModel);
                        queryTypeLibrary.UpdateClrTypeMapping(workspace.Assemblies.Select(ac => ac.Contents).ToArray());
                        return queryTypeLibrary;
                    }
                    else
                    {
                        return workspace.CurrentQueryRepository.TypeLibrary;
                    }
                });

            container.RegisterCustomResolver(
                typeof(IEntityModelConceptualDataServices),
                t =>
                {
                    var workspace = container.Resolve<AstoriaWorkspace>();

                    // Add data generation hints before creating structural data services
                    ResolveDataGenerationHints(workspace.ConceptualModel, container);

                    var builder = container.Resolve<IEntityModelConceptualDataServicesFactory>();
                    var services = builder.CreateConceptualDataServices(workspace.ConceptualModel);
                    ExceptionUtilities.CheckObjectNotNull(services, "Structural data services builder returned null unexpectedly");
//.........这里部分代码省略.........

        private static void InitializeEntityModelStructuralDataServices(IEntityModelConceptualDataServices services, IEnumerable<EntityContainer> entityContainers, DependencyInjectionContainer container)
        {
            var driver = container.Resolve<IEntityContainerDataPopulationDriver>();
            driver.StructuralDataServices = services;
            driver.Random = container.Resolve<IRandomNumberGenerator>();
            driver.ThresholdForNumberOfEntities = -1;

            foreach (var entityContainer in entityContainers)
            {
                driver.EntityContainer = entityContainer;
                EntityContainerData data;
                driver.TryPopulateNextData(out data);
                driver.TryPopulateNextData(out data);
            }
        }

        private static void ResolveDataGenerationHints(EntityModelSchema model, DependencyInjectionContainer container)
        {
            var entityModelHintsResolver = container.Resolve<IEntityModelDataGenerationHintsResolver>();
            var primitiveResolver = container.Resolve<IPrimitiveDataTypeToDataGenerationHintsResolver>();

            entityModelHintsResolver.ResolveDataGenerationHints(model, primitiveResolver);
        }

        private async void Start()
        {
            using (Lock())
            {
                Save();

                await Task.Run(
                    () =>
                    {
                        try
                        {
                            using (var universe = new Universe(NullSaveFile.Instance, DataLoader.LoadMod(_modName)))
                            {
                                using (var container = new DependencyInjectionContainer())
                                {
                                    var gameLoop = container.Resolve<GameLoop>();
                                    var connectionManager = container.Resolve<GameConnectionManager>();
                                    gameLoop.Post(() => { var notAwaited = connectionManager.ConnectUniverseAsync(universe); });

                                    var gameApp = container.Resolve<GameApp>();
                                    gameApp.Run();
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            if (Debugger.IsAttached)
                            {
                                Debugger.Break();
                            }

                            MessageBox.Show(ex.ToString(), "CubeHack", MessageBoxButton.OK, MessageBoxImage.Error);
                        }
                    });
            }
        }

        /// <summary>
        /// Initializes the global objects.
        /// </summary>
        /// <param name="dependencyInjectionContainer">The dependency injection container.</param>
        public void InitializeGlobalObjects(DependencyInjectionContainer dependencyInjectionContainer)
        {
            ExceptionUtilities.CheckArgumentNotNull(dependencyInjectionContainer, "dependencyInjectionContainer");

            // pre-resolve global objects
            foreach (var globalObject in this.implementations.Where(c => c.IsGlobal))
            {
                var result = dependencyInjectionContainer.Resolve(globalObject.ContractType);
                IInitializable init = result as IInitializable;
                if (init != null)
                {
                    init.Initialize();
                }
            }
        }

        /// <summary>
        /// The configuration of these dependencies will be called from other testcase hierarchies that do not inherit from this class.
        /// This method can be used in such hierarchies.
        /// </summary>
        /// <param name="container">container on which to register impelemntation dependencies</param>
        public static void ConfigureDependenciesHelper(DependencyInjectionContainer container)
        {
            container.Register<IClrTypeReferenceResolver, StronglyTypedClrTypeReferenceResolver>();
            container.Register<IObjectLayerCodeGenerator, StronglyTypedObjectLayerCodeGenerator>();
            container.Register<IQueryEvaluationStrategy, ClrQueryEvaluationStrategy>();
            container.Register<IModelGenerator, ODataV2ModelGenerator>();
            container.Register<IWorkspaceBuilder, ODataWorkspaceBuilder>(); // Is this also needed , since we register Custom Resolver below
            container.Register<IQueryRepositoryBuilder, AstoriaQueryRepositoryBuilderBase>();
            container.Register<IQueryDataSetBuilder, ODataQueryDataSetBuilder>();

            container.Register<IResourceLookup, AssemblyResourceLookup>();
            container.Register<IStringResourceVerifier, StringResourceVerifier>();
            container.Register<IQueryScalarValueToClrValueComparer, QueryScalarValueToClrValueComparer>();
            container.Register<IQueryExpressionEvaluator, LinqToAstoriaEvaluator>();
            container.Register<IClientCodeLayerGenerator, PocoClientCodeLayerGenerator>();

            container.Register<ILinqToAstoriaQueryEvaluationStrategy, LinqToAstoriaClrQueryEvaluationStrategy>();
            container.Register<IPrimitiveDataTypeResolver, NullPrimitiveDataTypeResolver>();
            container.Register<ILinqResultComparerContextAdapter, ODataObjectResultComparerContextAdapter>();

            container.Register<ISpatialClrTypeResolver, SpatialClrTypeResolver>();
            container.Register<ISpatialDataTypeDefinitionResolver, SpatialDataTypeDefinitionResolver>();
            container.Register<IPayloadTransformFactory, ODataLibPayloadTransformFactory>();

            container.RegisterCustomResolver(
                typeof(ODataTestWorkspace),
                t =>
                {
                    var builder = container.Resolve<ODataWorkspaceBuilder>();
                    var modelGenerator = container.Resolve<IModelGenerator>();
                    var workspace = builder.BuildWorkspace(modelGenerator.GenerateModel());
                    
                    return workspace;
                });

            container.RegisterCustomResolver(
                typeof(IQueryTypeLibraryBuilder),
                queryTypeLibBuilderResolver =>
                {
                    var queryEvaluationStrategy = container.Resolve<ILinqToAstoriaQueryEvaluationStrategy>();
                    var primitiveTypeResolver = container.Resolve<IPrimitiveDataTypeResolver>();
                    return new AstoriaQueryTypeLibraryBuilder(queryEvaluationStrategy, primitiveTypeResolver, new EdmDataTypeResolver());
                });

            // IQueryDataSet is built by the repository builder
            container.RegisterCustomResolver(
                typeof(IQueryDataSet),
                    t =>
                    {
                        var repository = container.Resolve<QueryRepository>();
                        return repository.DataSet;
                    });

            container.RegisterCustomResolver(
                typeof(QueryTypeLibrary),
                queryTypeLib =>
                {
                    var workspace = container.Resolve<ODataTestWorkspace>();
                    var queryTypeLibraryBuilder = container.Resolve<IQueryTypeLibraryBuilder>();
                    var queryTypeLibrary = queryTypeLibraryBuilder.BuildLibraryWithoutClrTypeMapping(workspace.ConceptualModel);
                    if (workspace.ObjectLayerAssembly != null)
                    {
                        queryTypeLibrary.UpdateClrTypeMapping(new[] { workspace.ObjectLayerAssembly });
                    }

                    return queryTypeLibrary;
                });

            container.RegisterCustomResolver(
                typeof(EntityContainerData),
                t =>
                {
                    // TODO: All Query tests fail when there is actual data, for now starting with empty data
                    var workspace = container.Resolve<ODataTestWorkspace>();
                    EntityContainerData data = null;
                    data = new EntityContainerData(workspace.ConceptualModel.GetDefaultEntityContainer());
                    
                    //var dataPopulationDriver = container.Resolve<EntityContainerDataPopulationDriver>();
                    //dataPopulationDriver.ThresholdForNumberOfEntities = -1;
                    //dataPopulationDriver.EntityContainer = workspace.ConceptualModel.GetDefaultEntityContainer();
                    //dataPopulationDriver.TryPopulateNextData(out data);
                    
                    return data;
                });

            // QueryRepository is constructed by calling IQueryRepositoryBuilder.CreateQueryRepository
            container.RegisterCustomResolver(
                typeof(QueryRepository),
                t =>
                {
                    var repositoryBuilder = container.Resolve<IQueryRepositoryBuilder>();
                    var workspace = container.Resolve<ODataTestWorkspace>();
                    var queryTypeLibrary = container.Resolve<QueryTypeLibrary>();
                    var entityContaineData = container.Resolve<EntityContainerData>();

//.........这里部分代码省略.........