public void CreateMovieWorks() { // arrange (use the context directly - we assume that works) var options = new DbContextOptionsBuilder <MoviesDBContext>() .UseInMemoryDatabase("createmovie_test").Options; using (var db = new MoviesDBContext(options)) { db.Genre.Add(new Genre { Name = "a" }); db.SaveChanges(); } // act (for act, only use the repo, to test it) using (var db = new MoviesDBContext(options)) { var repo = new MovieRepository(db); Movie movie = new Movie { Name = "b" }; repo.CreateMovie(movie, "a"); repo.SaveChanges(); } // assert (for assert, once again use the context directly to verify.) using (var db = new MoviesDBContext(options)) { Movie movie = db.Movie.Include(m => m.Genre).First(m => m.Name == "b"); Assert.Equal("b", movie.Name); Assert.NotNull(movie.Genre); Assert.Equal("a", movie.Genre.Name); Assert.NotEqual(0, movie.Id); // should get some generated id } }
public void CreateMovieWithoutSaveChangesDoesntWork() { // arrange (use the context directly - we assume that works) var options = new DbContextOptionsBuilder <MoviesDBContext>() .UseInMemoryDatabase("createmoviedoesntsavechanges_test").Options; using (var db = new MoviesDBContext(options)) { db.Genre.Add(new Genre { Name = "a" }); db.SaveChanges(); } // act (for act, only use the repo, to test it) using (var db = new MoviesDBContext(options)) { var repo = new MovieRepository(db); Movie movie = new Movie { Name = "b" }; repo.CreateMovie(movie, "a"); // not calling repo.SaveChanges } // assert (for assert, once again use the context directly to verify.) using (var db = new MoviesDBContext(options)) { Movie movie = db.Movie.Include(m => m.Genre).FirstOrDefault(m => m.Name == "b"); Assert.Null(movie); } }
static void ChangeMovie() { using (var db = new MoviesDBContext()) { // get the first movie by name // this entity is tracked. var movie = db.Movie.OrderBy(m => m.Name).First(); // edit it movie.Name = "Solo"; // create (untracked) genre entity var genre = new Genre { Name = "Action/Adventure" }; // begin tracking it as an "added" entity //db.Add(genre); movie.Genre = genre; // the new genre gets added to the db because the movie // referencing it is tracked. // make sure that we are tracking all changes for this object // (if it's untracked, start tracking it) db.Update(movie); // update the database, picking up tracked changes. db.SaveChanges(); } }
static void PrintMovies() { var movies = new List <Movie>(); using (var db = new MoviesDBContext(options)) { // at this point, we haven't connected to the db yet // this winds up as a "SELECT * FROM Movies.Movie" somewhere movies = db.Movie.ToList(); // this does not fetch the full "entity graph" of the movie - // "navigation properties" like Genre are null. // this winds up as a SELECT with a join. movies = db.Movie.Include(m => m.Genre).ToList(); // with .Include, we fetch the related properties so they are not null. // EF stores the result sets in the DbSets of the DbContext, so // this second access will use cached values. (faster) movies = db.Movie.Include(m => m.Genre).ToList(); } foreach (var item in movies) { Console.WriteLine($"movie ID {item.Id}, name {item.Name}, genre {item.Genre.Name}"); } }
static void PrintMovies() { using (var db = new MoviesDBContext()) { foreach (var item in db.Movie.Include(m => m.Genre)) { Console.WriteLine($"Name {item.Name}," + $" genre {item.Genre.Name}"); } } }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); Database.SetInitializer(new ApplicationMovieContext()); var dbMovie = new MoviesDBContext(); //dbMovie.Database.Initialize(true); Database.SetInitializer(new ApplicationDbInitializer()); var db = new ApplicationDbContext(); db.Database.Initialize(true); }
public IEnumerable <Movies> Get() { using (var _context = new MoviesDBContext()) { /*Movies movie = new Movies(); * //movie.MoviesId = 1; * movie.Name = "First Title"; * movie.Year = 2000; * * _context.Movies.Add(movie); * * _context.SaveChanges();*/ return(_context.Movies.ToList()); } }
public void AddMoviesToDB(MoviesDBContext dbContext) { MovieService movieService = new MovieService(); foreach (var movie in movieService.GetMovies()) { MovieViewModel oNew = new MovieViewModel(); oNew.MovieTitle = movie.MovieTitle; oNew.ReleaseYear = movie.ReleaseYear; oNew.Genre = movie.Genre; dbContext.Movies.Add(oNew); dbContext.SaveChanges(); } }
static void EditSomething() { using (var db = new MoviesDBContext(options)) { // this is going to be executed right away Genre actionGenre = db.Genre.FirstOrDefault(g => g.Name == "Action"); // (First throws exceptions, FirstOrDefault just returns null when there's none) if (actionGenre != null) { actionGenre.Name = "Action/Adventure"; // because actionGenre object is tracked, the context sees any changes and applies them. db.SaveChanges(); } } }
static void AccessWithRepo() { using (var db = new MoviesDBContext(options)) { IMovieRepository movieRepo = new MovieRepository(db); movieRepo.CreateMovie(new Movie { Name = "Harry Potter" }, "Action/Adventure"); movieRepo.SaveChanges(); foreach (var movie in movieRepo.GetAllMoviesWithGenres()) { Console.WriteLine(movie.Name); } } }
static void AddAMovie() { using (var db = new MoviesDBContext(options)) { // get first alphabetical name // (no network access yet!) var firstMovieQuery = db.Movie.Include(m => m.Genre).OrderBy(m => m.Name); Movie movie = firstMovieQuery.First(); // that fetched only the one movie, not all of them var newMovie = new Movie { Name = movie.Name + " 2", Genre = movie.Genre }; // few different ways to add this. (aka track the entity) db.Add(newMovie); // this one guesses which DbSet based on the type. //db.Movie.Add(newMovie); // we can add this movie to the genre's navigation property "Movie" collection. //movie.Genre.Movie.Add(newMovie); // after doing any of those, the change to the database is recorded in the DbContext // but not yet applied to the DB. // SaveChanges applies all the tracked changes in one transaction db.SaveChanges(); // now, those extra properties on the newMovie that we didn't set (like Id) // have been filled in by the dbcontext. // (you can continue working and savechanges multiple times on one dbcontext) } // objects you get out of the DbSets are "tracked" by the context. // any changes you make to them will be noticed and applied to the DB // on the next SaveChanges. // objects you create yourself are NOT tracked - track them with db.Add, // db.Update, or adding them to a tracked entity's navigation property. }
static void EarlierCode() { PrintMovies(); ChangeMovie(); PrintMovies(); var movie = new Movie { Id = 1, Name = "Toy Story", GenreId = 1 }; // at this point, movie is untracked. using (var db = new MoviesDBContext()) { // begin tracking the movie, based on the Id it has. // treat any difference as updates to be made. db.Update(movie); // push the changes to the db db.SaveChanges(); } }
public void SaveChangesWithNoChangesDoesntThrowException() { // arrange var options = new DbContextOptionsBuilder <MoviesDBContext>() .UseInMemoryDatabase("no_changes_test").Options; using (var db = new MoviesDBContext(options)) { // do nothing // (just creating the DbContext class with in-memory options // automatically creates the in-memory DB too.) } // act using (var db = new MoviesDBContext(options)) { var repo = new MovieRepository(db); repo.SaveChanges(); // assert } // assert // (no exception should have been thrown) }
public MovieController(MoviesDBContext db) { this.db = db; }
public AdminService(MoviesDBContext context, ILoggerManager loggerManager) { _context = context; _loggerManager = loggerManager; }
public HomeController(ILogger <HomeController> logger, IMoviesRepository repository, MoviesDBContext context) { _logger = logger; _repository = repository; _context = context; }
public genreController(MoviesDBContext context) { _context = context; }
public static int staticID; //global variable to store id of editing movie between pages //Constructor public HomeController(ILogger <HomeController> logger, MoviesDBContext context) { _logger = logger; _context = context; }
public EfRepository(MoviesDBContext dbContext) { _dbContext = dbContext; }
public MoviesController() { MoviesDBContext.Intialize(); }
public RentalRepository(MoviesDBContext context) { _context = context; }
public MoviesComingSoonDBModelsController(MoviesDBContext context) { _context = context; }
public ProfileController(MoviesDBContext context) { _context = context; }
public MovieService(MoviesDBContext context) { _context = context; }
public TopRatedIndian2ModelController(MoviesDBContext context) { _context = context; }
public MoviesController(MoviesDBContext context) { _context = context; }
public HomeController(MoviesDBContext con) { context = con; }
public UserRepository(MoviesDBContext context) { _context = context; }
public MoviesInTheatersModelsController(MoviesDBContext context) { _context = context; }
public TopRatedMovies1ModelController(MoviesDBContext context) { _context = context; }
public HomeController(MoviesDBContext dBContextMovies, IMovieService movieService) { _DBContextMovies = dBContextMovies; _MovieService = movieService; }