Don't save null image data if image was not re-uploaded Asp.net mvc

The issue is going to be trying to use something like "SaveOrUpdate" if that is resolving to EF's AddOrUpdate which is intended for migrations & initial data population scenarios, or boiling down to a DbContext.Update(doctor) then your data gets overwritten with #null. You're giving EF an entity to insert or update without any consideration of data that is already there. EF will merely do an Exists check then issue an INSERT or effectively an UPDATE * based on ALL fields populated as they are in the provided entity.

Strictly for a RESTful API, you should be distinguishing between "Add" and "Update" by issuing a POST or PUT respectively. On POST you take the data, create a new model, add it to the DB Context and SaveChanges. For PUT you fetch the current model, update the appropriate values, and SaveChanges. A PUT operation should never insert the row if not found.

Your method looks like it's meant to only update an existing record:

[HttpPut]
public ActionResult Edit(int id, HttpPostedFileBase image1, FormCollection collection)
{
    using (var context = new AppDbContext())
    {
        try
        {
            var doctor = context.Doctors.Single(x => x.Id == id); // Will throw if Dr not found.
            doctor.D_city = collection["D_city"].ToString();
            doctor.D_egn = collection["D_egn"].ToString();
            doctor.D_email = collection["D_email"].ToString();
            doctor.D_family_name = collection["D_family_name"].ToString();
            doctor.D_first_name = collection["D_first_name"].ToString();
            doctor.D_gender = collection["D_gender"].ToString();
            doctor.D_mid_name = collection["D_mid_name"].ToString();
            doctor.D_phone = collection["D_phone"].ToString();
            doctor.D_specialty = collection["D_specialty"].ToString();
            doctor.D_room = collection["D_room"].ToString();
            doctor.D_floor = collection["D_floor"].ToString();

            if (image1 != null)
            {
                doctor.D_picture = new byte[image1.ContentLength];
                image1.InputStream.Read(doctor.D_picture, 0, image1.ContentLength);
            }

            context.SaveChanges();
            return RedirectToAction("Index");
        }
        catch
        {   // do more than this. :)
            return View();
        }
    }
}

Ideally the DbContext or a UnitOfWork is injected. It's hard to know what you Session implementation does or interacts with the DbContext. I generally don't recommend trying to abstract away the EF DbContext as it really cripples the capability it offers for working with data entities efficiently. For update operations, fetch the existing entity and then copy the values across. The DbContext by default uses tracked entities so as you actually change values, those will be included into an UPDATE statement. Anything that isn't explicitly changed will be left as-is and doesn't get appended into the UPDATE query.

For potentially large data that is used infrequently like Images, I would recommend considering isolating those to a related table/entity. I.e.

public class DoctorImage
{
    [Key]
    public int Id { get; set; } // == Doctor.Id
    public byte[] Image { get; set; }
}

Where the relationship of Doctor to DoctorImage is set up as HasOptional.WithRequired / HasOne.WithOne. The benefit is that loading the image when dealing with Doctors is entirely optional. Unless you use projection explicitly everywhere, loading an existing Doctor entity would cause EF to fetch the Image every time when you probably don't need it. By separating it, you only fetch it when explicitly eager/lazy loaded. Listing Doctors for instance can easily be done without the overhead of loading all of their image data.