The way Entity Framework works is that using the DbContext class, we can retrieve all the data by simply accessing the model collection associated with the view. So, to fetch a list of items, we just need to get the model collection from the context class:

using(ToDoDBEntities db = new ToDoDBEntities())
{
    IEnumerable<ToDo> todoItems = db.ToDos;
}

Let's try to understand the preceding code:

If we want to retrieve a single item from the model collection, we have many ways of doing it. Typically, we can use any LINQ function to fetch the single record from the model collection. Also, if we want to fetch the result using the primary key, we can use the Find method to do it. Let's look at a few ways in which we can retrieve a single item using Entity Framework:

using (ToDoDBEntities db = new ToDoDBEntities())
{
  ToDo todo1 = db.ToDos.Find(id);

  ToDo todo3 = db.ToDos.FirstOrDefault(item => item.TodoItem == "Test item");
  ToDo todo2 = db.ToDos.SingleOrDefault(item => item.TodoItem == "Test item");    
  

}

Let's try to understand the preceding code:

To create an item, we simply need to create the model, assign the values in the model properties, and then call the SaveChanges method on Entity Framework. Now let's see how we can create a ToDo item using Entity Framework:

using (ToDoDBEntities db = new ToDoDBEntities())
{
    ToDo todoItem = new ToDo();
    todoItem.TodoItem = "This is a test item.";
    todoItem.IsDone = false;
     db.ToDos.Add(todoItem);

    db.SaveChanges();
}

Let's try to understand the preceding code:

To update an existing item, there are two possibilities. The first possibility is that we will fetch the model, update some of the properties of the model, and then save the updated model in the database. To do this, we just need to fetch the required model using the DbContext class, update its properties, and then call the SaveChanges method on the DbContext object. Let's try to update a model with the ID 3:

using (ToDoDBEntities db = new ToDoDBEntities())
{
    int id = 3;
    ToDo todo = db.ToDos.Find(id);

    todo.TodoItem = "This has been updated";
    todo.IsDone = false;
    db.SaveChanges();
}

Let's try to understand the preceding code:

What is happening in the preceding code is that the DbContext class was still in scope when the entity was being updated and saved. The DbContext class is able to track the changes in the entity if it is in scope. However, this approach is rarely useful, because in real applications in a typical n-tier application, the entities will be passed through multiple layers, and any layer can update this entity, and at the time of updating the entity, objects are usually disconnected from the context.

So to perform the updates in such a disconnected environment, we need to attach the updated entity back to let the DbContext class identify the modifications made in the entity, and then generate the appropriate update SQL accordingly and persist the updates in the database. This can be done by attaching the entity back to the DbContext class. Let's see how a ToDo model can be attached to the DbContext class if it is being passed from a different tier:

using (ToDoDBEntities db = new ToDoDBEntities())
{
  db.Entry(todo).State = EntityState.Modified;
  db.SaveChanges();
}

Let's try to understand the preceding code:

To delete an item, we just need to fetch the item that needs to be deleted, call the Remove method on the model collection, and call the SaveChanges method on the DbContext class. Let's try to delete a model with the ID 3:

using (ToDoDBEntities db = new ToDoDBEntities())
{
    int id = 3;
   ToDo todo = db.ToDos.Find(id);
    db.ToDos.Remove(todo);
    db.SaveChanges();
}

Let's try to understand the preceding code: