C# ServiceCollection.AddEntityFramework方法代码示例

        public TestBase()
        {
            if (ServiceProvider == null)
            {
                var services = new ServiceCollection();

                // set up empty in-memory test db
                services.AddEntityFramework()
                    .AddInMemoryDatabase()
                    .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase());

                // add identity service
                services.AddIdentity<ApplicationUser, IdentityRole>()
                    .AddEntityFrameworkStores<AllReadyContext>();
                var context = new DefaultHttpContext();
                context.Features.Set<IHttpAuthenticationFeature>(new HttpAuthenticationFeature());
                services.AddSingleton<IHttpContextAccessor>(h => new HttpContextAccessor { HttpContext = context });

                // Setup hosting environment
                IHostingEnvironment hostingEnvironment = new HostingEnvironment();
                hostingEnvironment.EnvironmentName = "Development";
                services.AddSingleton(x => hostingEnvironment);

                // set up service provider for tests
                ServiceProvider = services.BuildServiceProvider();
            }
        }

        public HomeControllerTests()
        {
            // Database setup
            var services = new ServiceCollection();
            services.AddEntityFramework()
                    .AddSqlServer()
                    .AddInMemoryDatabase()
                    .AddDbContext<DataDbContext>(options =>
                        options.UseInMemoryDatabase()
                    );

            // Dependencies initializations
            _pageConfiguration = new FakePageConfiguration();

            var optionsBuilder = new DbContextOptionsBuilder<DataDbContext>();
            optionsBuilder.UseInMemoryDatabase();
            _dataDbContext = new DataDbContext(optionsBuilder.Options);

            _contentRepository = new ContentRepository(_dataDbContext);
            _humanReadableContentService = new HumanReadableContentService(_pageConfiguration, _contentRepository);

            _languageManipulationService = new LanguageManipulationService();

            // Controller initialization
            _homeController = new PersonalWebsite.Controllers.HomeController(
                _pageConfiguration,
                _humanReadableContentService,
                _languageManipulationService
            );
        }

        private static async Task Can_use_an_existing_closed_connection_test(bool openConnection)
        {
            var serviceCollection = new ServiceCollection();
            serviceCollection
                .AddEntityFramework()
                .AddSqlServer();

            var serviceProvider = serviceCollection.BuildServiceProvider();

            using (var store = SqlServerNorthwindContext.GetSharedStore())
            {
                var openCount = 0;
                var closeCount = 0;
                var disposeCount = 0;

                using (var connection = new SqlConnection(store.Connection.ConnectionString))
                {
                    if (openConnection)
                    {
                        await connection.OpenAsync();
                    }

                    connection.StateChange += (_, a) =>
                        {
                            if (a.CurrentState == ConnectionState.Open)
                            {
                                openCount++;
                            }
                            else if (a.CurrentState == ConnectionState.Closed)
                            {
                                closeCount++;
                            }
                        };
#if !DNXCORE50
                    connection.Disposed += (_, __) => disposeCount++;
#endif

                    using (var context = new NorthwindContext(serviceProvider, connection))
                    {
                        Assert.Equal(91, await context.Customers.CountAsync());
                    }

                    if (openConnection)
                    {
                        Assert.Equal(ConnectionState.Open, connection.State);
                        Assert.Equal(0, openCount);
                        Assert.Equal(0, closeCount);
                    }
                    else
                    {
                        Assert.Equal(ConnectionState.Closed, connection.State);
                        Assert.Equal(1, openCount);
                        Assert.Equal(1, closeCount);
                    }

                    Assert.Equal(0, disposeCount);
                }
            }
        }

        public GenreMenuComponentTest()
        {
            var services = new ServiceCollection();
            services.AddEntityFramework()
                      .AddInMemoryDatabase()
                      .AddDbContext<MusicStoreContext>(options => options.UseInMemoryDatabase());

            _serviceProvider = services.BuildServiceProvider();
        }

 public BlogServiceTestsAdvanced()
 {
     // Create a service collection to be shared by all test methods
     _serviceCollection = new ServiceCollection();
     _serviceCollection
         .AddEntityFramework()
         .AddInMemoryDatabase()
         .AddDbContext<BloggingContext>(c => c.UseInMemoryDatabase());
 }

        public PersonDbContextTest()
        {
            var services = new ServiceCollection();

            services.AddEntityFramework()
                      .AddInMemoryDatabase()
                      .AddDbContext<StoreDbContext>(options => options.UseInMemoryDatabase());

            serviceProvider = services.BuildServiceProvider();
        }

        public BaseTest()
        {
            var services = new ServiceCollection();

            services.AddEntityFramework()
                          .AddInMemoryDatabase()
                          .AddDbContext<ApplicationDbContext>();

            ServiceProvider = services.BuildServiceProvider();
        }

        static void Main(string[] args)
        {
            var len = path.Length;
            var fileSystemItems = Directory.EnumerateFiles(Path.Combine(path, Elizabeth), "o_*", SearchOption.AllDirectories).AsParallel().Select(f =>
            {
                var text = File.ReadAllText(f.Replace("o_", ""));
                var sourceDirectoryLength = path.Length + Elizabeth.Length;
                var year = string.Concat(f.Skip(sourceDirectoryLength).Take(4));
                var month = string.Concat(f.Skip(sourceDirectoryLength + 5).TakeWhile(ch => ch != Convert.ToChar(@"\")));
                DateTime date;
                if (!DateTime.TryParseExact(year + "-" + month + "-" + "1", "yyyy-MMMM-d", null, System.Globalization.DateTimeStyles.None, out date))
                    date = DateTime.Now;
                var idx = text.IndexOf(rdfLi);
                string tags = (idx > -1)
                                        ? text.Substring(idx + rdfLi.Length, text.Substring(idx).IndexOf(endRdfLi) - rdfLi.Length)
                                        : string.Empty;

                var split2 = text.IndexOf(xmpRating);
                int rating = int.Parse(split2 > -1
                                                    ? text.Substring(split2 + xmpRating.Length, 1)
                                                    : "5");
                var uri = f.Substring(len);
                var image = System.Drawing.Image.FromFile(f);
                var heightRatio = (decimal)image.Height / (decimal)image.Width;
                return new PhotoInfo { uri = PhotoInfo.baseuri + uri.Replace("\\", "/"), heightRatio = heightRatio, rating = rating, tags = tags, date = date };
            }).ToDictionary(p => p.uri);
            var services = new ServiceCollection();
            services.AddEntityFramework().AddSqlServer().AddDbContext<PhotoContext>(optionsBuilder =>
                                                optionsBuilder.
                                                    UseSqlServer(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString).
                                                    MigrationsAssembly("MVC6"));

            using (PhotoContext context = services.BuildServiceProvider().GetService<PhotoContext>())
            {
                var dbItems = context.PhotoInfos.ToDictionary(p => p.uri);
                context.RemoveRange(dbItems.Values.Where(p => !fileSystemItems.ContainsKey(p.uri)));
                foreach (var item in fileSystemItems.Values)
                {
                    PhotoInfo dbItem;
                    if (dbItems.TryGetValue(item.uri, out dbItem))
                    {
                        dbItem.date = item.date;
                        dbItem.rating = item.rating;
                        dbItem.tags = item.tags;
                        dbItem.heightRatio = item.heightRatio;
                        context.Update(dbItem);
                    }
                    else
                    {
                        context.Add(item);
                    }
                }
                context.SaveChanges();
            }
        }

        public static InMemoryContext CreateContext()
        {
            var services = new ServiceCollection();
            services.AddEntityFramework().AddInMemoryDatabase();
            var serviceProvider = services.BuildServiceProvider();

            var db = new InMemoryContext();
            db.Database.EnsureCreated();

            return db;
        }

		public static IServiceProvider Create()
		{
			var services = new ServiceCollection();

			services.AddEntityFramework()
					  .AddInMemoryDatabase()
					  .AddDbContext<MusicStoreContext>(options => options.UseInMemoryDatabase());

			var serviceProvider = services.BuildServiceProvider();
			return serviceProvider;
        }

        public ShoppingCartControllerTest()
        {
            var services = new ServiceCollection();

            services.AddEntityFramework()
                      .AddInMemoryDatabase()
                      .AddDbContext<MusicStoreContext>(options => options.UseInMemoryDatabase());

            services.AddMvc();

            _serviceProvider = services.BuildServiceProvider();
        }

		public static IServiceProvider GetServiceProvider()
		{
			var services = new ServiceCollection();
			services.AddMvc();
			services.AddEntityFramework()
				.AddInMemoryDatabase()
				.AddDbContext<ChatLeIdentityDbContext>(options => options.UseInMemoryDatabase());
			services.AddInstance<ILoggerFactory>(new LoggerFactory());
			services.AddIdentity<ChatLeUser, IdentityRole>();
			services.AddChatLe();
			return services.BuildServiceProvider();
		}

        public SurveyStoreTests()
        {
            var optionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();
            optionsBuilder.UseInMemoryDatabase();
            _options = optionsBuilder.Options;

            _serviceCollection = new ServiceCollection();
            _serviceCollection
                .AddEntityFramework()
                .AddInMemoryDatabase();
            _serviceCollection.AddTransient<ApplicationDbContext>(provider => new ApplicationDbContext(provider, _options));
            _serviceCollection.AddTransient<SqlServerSurveyStore>();
        }

        private void ConfigureServices(ServiceCollection services)
        {
            var connectionString = Configuration["Data:DefaultConnection:ConnectionString"];
            services.AddEntityFramework()
                .AddSqlServer()
                .AddDbContext<CoffeeStoreContext>(options =>
                {
                    options.UseSqlServer(connectionString);
                }
                );

            services.AddScoped<ICoffeeStoreContext>(provider => provider.GetService<CoffeeStoreContext>());
        }

        public SurveyControllerTests()
        {
            _surveyService = new Mock<ISurveyService>();
            _logger = new Mock<ILogger<SurveyController>>();
            _authorizationService = new Mock<IAuthorizationService>();

            var services = new ServiceCollection();
            services.AddEntityFramework()
                .AddInMemoryDatabase()
                .AddDbContext<ApplicationDbContext>(options => options.UseInMemoryDatabase());

            _target = new SurveyController(_surveyService.Object, _logger.Object, _authorizationService.Object);
        }