MVC 3 EF 4.1 dbContext - Eliminar un objeto de datos de uno a muchos con una relación de clave externa no anulable

Estoy usando MVC 3, EF 4.1 y dbContext. Necesito saber cómo eliminar una entidad en una relación de uno a muchos con una clave foránea no anulable.

Cuando elimino la entidad secundaria y ejecuto SaveChanges, aparece el error:

La operación falló: la relación no se pudo cambiar porque una o más de las propiedades de clave externa no son anulables. Cuando se realiza un cambio en una relación, la propiedad de clave externa relacionada se establece en un valor nulo. Si la clave externa no admite valores nulos, se debe definir una nueva relación, se debe asignar a la propiedad de clave externa otro valor no nulo o se debe eliminar el objeto no relacionado.

Desde otras publicaciones, entiendo que el uso de Eliminar (entidad) marca la entidad para su eliminación. Durante SaveChanges, EF establece la clave externa en Null y se produce el error anterior.

He encontrado algunas publicaciones que usan DeleteObject en la entidad secundaria en lugar de Eliminar; sin embargo, el enfoque DeleteObject parece haberse eliminado debido a la adición a dbContext y DbSet.

He encontrado publicaciones que sugieren modificar la relación de clave externa EDMX para que sea Nullable. La modificación de EDMX está bien, pero cada vez que se realiza un Modelo de actualización para la base de datos, estos cambios se modifican y se deben volver a aplicar. No es óptimo.

Otra publicación sugirió crear una entidad proxy con las relaciones de clave externa establecidas en Nullable, pero no entiendo ese enfoque. Parece sufrir el mismo problema que la modificación de EDMX, ya que el contexto se actualiza automáticamente cuando se guardan los cambios en EDMX.

Mi modelo simplificado es:

public partial class User
{
    public User()
    {
        this.UserContacts = new HashSet<UserContact>();
    }

    public long userId { get; set; }
    public string userEmail { get; set; }
    public string userPassword { get; set; }
    public string userFirstName { get; set; }
    public string userLastName { get; set; }
     . . .
    public virtual Country Country { get; set; }
    public virtual State State { get; set; }
    public virtual ICollection<UserContact> UserContacts { get; set; }
}

}

public partial class UserContact
{
    public long userContactId { get; set; }
    public long userContactUserId { get; set; }
    public long userContactTypeId { get; set; }
    public string userContactData { get; set; }

    public virtual ContactType ContactType { get; set; }
    public virtual User User { get; set; }
}

El userContactUserId y userContactTypeId son claves foráneas requeridas.

En el contenedor dbContext, tanto Users como UserContact son DbSet.

Tengo un ViewModel para el Usuario y un ViewModel para el UserContact de la siguiente manera

public class UserContactViewModel
{
    [HiddenInput]
    public long UserContactId { get; set; }

    [HiddenInput]
    public long UserContactUserId { get; set; }

    [Display(Name = "Contact")]
    [Required]
    public string ContactData { get; set; }

    [Required]
    public long ContactType { get; set; }

    [HiddenInput]
    public bool isDeleted { get; set; }

}

    public class MyProfileViewModel
    {

        [HiddenInput]
        public long UserId { get; set; }

        [Required]
        [Display(Name = "First Name")]
        [StringLength(100)]
        public string FirstName { get; set; }

        [Required]
        [StringLength(100)]
        [Display(Name = "Last Name")]
        public string LastName { get; set; }
        ....
        public IEnumerable<UserContactViewModel> Contacts { get; set; }

}

l guardar los cambios en el perfil del usuario, recorro la lista de entidades UserContactViewModel para determinar cuáles se han agregado, modificado o eliminado.

                    foreach (var c in model.Contacts)
                    {
                        UserContact uc = usr.UserContacts.Single(con => con.userContactId == c.UserContactId);
                        if (uc != null)
                        {
                            if (c.isDeleted == true)  // Deleted UserContact
                            {
                                ctx.UserContacts.Remove(uc);  // Remove doesn't work
                            }
                            else  //  Modified UserContact
                            {
                                uc.userContactData = c.ContactData;
                                uc.userContactTypeId = c.ContactType;
                                ctx.Entry(uc).State = EntityState.Modified;
                            }
                        }
                        else  // New UserContact
                        {
                            usr.UserContacts.Add(new UserContact { userContactUserId = model.UserId, userContactData = c.ContactData, userContactTypeId = c.ContactType });
                        }
                    }

Agradecería cualquier ayuda.