實體框架：刪除子實體

Question

我正在使用EF，但是我禁用了延遲加載。 相反，我使用的是急切的加載，因此我創建了自己的服務：

/// <summary>
/// Generic service for entity framework
/// </summary>
/// <typeparam name="T">An entity model</typeparam>
public class Service<T> : IService<T> where T : class
{
    // Create our private properties
    private readonly DbContext _context;
    private readonly DbSet<T> _dbEntitySet;

    /// <summary>
    /// Default constructor
    /// </summary>
    /// <param name="context">The database context</param>
    public Service(DbContext context)
    {
        // Assign our context and entity set
        _context = context ?? throw new ArgumentNullException("context");
        _dbEntitySet = context.Set<T>();
    }

    /// <summary>
    /// Gets all the entities
    /// </summary>
    /// <param name="includes">Option includes for eager loading</param>
    /// <returns></returns>
    public IQueryable<T> List(params string[] includes)
    {

        // Create a query
        IQueryable<T> query = _dbEntitySet;

        // For each include, append to our query
        if (includes != null)
            foreach (var include in includes)
                query = query.Include(include);

        // Return our query
        return query;
    }

    /// <summary>
    /// Creates an entity
    /// </summary>
    /// <param name="model"></param>
    public void Create(T model) => _dbEntitySet.Add(model);

    /// <summary>
    /// Updates an entity
    /// </summary>
    /// <param name="model"></param>
    public void Update(T model) => _context.Entry<T>(model).State = EntityState.Modified;

    /// <summary>
    /// Removes an entity
    /// </summary>
    /// <param name="model"></param>
    public void Remove(T model) => _context.Entry<T>(model).State = EntityState.Deleted;

    /// <summary>
    /// Saves the database context changes
    /// </summary>
    /// <returns></returns>
    public async Task SaveChangesAsync()
    {
        try
        {
            // Save the changes to the database
            await _context.SaveChangesAsync();
        }
        catch (DbEntityValidationException ex)
        {

            // Retrieve the error messages as a list of strings.
            var errorMessages = ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage);

            // Join the list to a single string.
            var fullErrorMessage = string.Join("; ", errorMessages);

            // Combine the original exception message with the new one.
            var exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);

            // Throw a new DbEntityValidationException with the improved exception message.
            throw new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors);
        }
        catch (DbUpdateException ex)
        {
            throw;
        }
    }

    /// <summary>
    /// Executes a stored procedure in sql
    /// </summary>
    /// <param name="procedure">The name of the sproc</param>
    /// <param name="parameters">the sql params for the sproc</param>
    /// <returns></returns>
    public DbRawSqlQuery<T> ExecuteProcedure(string procedure, List<SqlParameter> parameters)
    {
        var results = _context.Database.SqlQuery<T>($"exec {procedure} { CreateQueryStringFromParams(parameters) }");
        return results;
    }

    /// <summary>
    /// Dispose
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    /// <summary>
    /// Creates the input string to run sprocs in sql with EF by converting the sql params into a nice string
    /// </summary>
    /// <param name="parameters"></param>
    /// <returns></returns>
    private static string CreateQueryStringFromParams(IEnumerable<SqlParameter> parameters)
    {
        var response = "";
        var list = parameters as IList<SqlParameter> ?? parameters.ToList();
        var length = list.Count;

        for (var i = 0; i < length; i++)
        {
            response += $"{list[i].ParameterName}=\"{list[i].Value}\"";
            if (i != length - 1)
                response += ", ";
        }

        return response;
    }

    /// <summary>
    /// Disposes of any attached resources
    /// </summary>
    /// <param name="disposing">A boolean indicating whether the object is being disposed</param>
    protected virtual void Dispose(bool disposing)
    {

        // If we are disposing, dispose of our context
        if (disposing)
            _context.Dispose();
    }
}

然后，每個服務都將繼承此類：

/// <summary>
/// Handles all Group related methods
/// </summary>
public class GroupService : Service<Group>, IGroupService
{

    /// <summary>
    /// The default constructor
    /// </summary>
    /// <param name="unitOfWork"></param>
    public GroupService(DbContext context) : base(context)
    {
    }

    /// <summary>
    /// Lists groups by category
    /// </summary>
    /// <param name="categoryId">The id of the category</param>
    /// <param name="includes"></param>
    /// <returns></returns>
    public IQueryable<Group> List(int categoryId, params string[] includes) => List(includes).Where(m => m.CategoryId == categoryId);

    /// <summary>
    /// Gets a single Group by id
    /// </summary>
    /// <param name="id">The id of the Group</param>
    /// <returns></returns>
    public async Task<Group> GetAsync(int id, params string[] includes) => await List(includes).Where(model => model.Id == id).SingleOrDefaultAsync();
}

每個“實體”都有一個與此GroupService相似的類。 我也為每種實體類型提供了提供程序 ，這是我的刪除方法：

/// <summary>
/// Delete a Group
/// </summary>
/// <param name="id">The Group id</param>
/// <returns></returns>
public async Task<bool> DeleteAsync(int id)
{

    // Get our model
    var model = await _service.GetAsync(id, "Questions");

    // For each question, remove from the database
    if (model.Questions != null)
        foreach (var question in model.Questions.ToList())
            if (!await _questionProvider.Value.DeleteAsync(question.Id, false))
                throw new Exception("Failed to delete the questions");

    // Update our Questions
    model.Questions = null;

    // Save our model
    _service.Remove(model);

    // Save the database changes
    await _service.SaveChangesAsync();

    // Return true
    return true;
}

如您所見，我只是撤回了問題。

如果有問題，那么我將調用questionProvider的 delete方法，該方法非常相似：

/// <summary>
/// Delete a question
/// </summary>
/// <param name="id">The question id</param>
/// <param name="saveChanges">Saves the changes to the database after the delete (default true)</param>
/// <returns></returns>
public async Task<bool> DeleteAsync(int id, bool saveChanges = true)
{

    // Get our model
    var model = await _service.GetAsync(id, "Answers");

    // For each answer, delete from the database
    if (model.Answers != null)
        foreach (var answer in model.Answers.ToList())
            if (!await _answerProvider.Value.DeleteAsync(answer.Id, false))
                throw new Exception("Failed to delete the answers");

    // Update our Answers
    model.Answers = null;

    // Save our model
    _service.Remove(model);

    // Save the database changes
    if (saveChanges) await _service.SaveChangesAsync();

    // Return true
    return true;
}

如您所見，在刪除所有子級之前，我不會保存上下文更改。 現在，我必須指出，我不是要直接從父母那里移除孩子。 相反，我是從其自己的集合中刪除該實體，然后將該屬性設置為null。 完成所有操作后，我保存更改，但出現此錯誤：

操作失敗：由於一個或多個外鍵屬性不可為空，因此無法更改該關系。 對關系進行更改時，相關的外鍵屬性將設置為空值。 如果外鍵不支持空值，則必須定義新的關系，必須為外鍵屬性分配另一個非空值，或者必須刪除不相關的對象。

有誰知道我可以用與我嘗試實現的方法類似的方法刪除實體？

Answer 1

在閱讀了其他一些有類似問題的人之后，這個問題很容易解決。 我只是從以下位置更改了Service.cs中的一行代碼：

public void Remove(T model) => _context.Entry<T>(model).State = EntityState.Deleted;

至：

public void Remove(T model) => _dbEntitySet.Remove(model);

那行得通。

---

更新

我還發現，急切的負載需要包括將受到影響的所有導航屬性。 所以，如果我要刪除的有答案和答案的問題中有公式 ，在獲取調用必須是：

var model = await _service.GetAsync(id, "Answers.Formulas");

如果不包括在內，則會出現錯誤。