Question

假设我有这段代码：

class Score
{
     public Update(int score)
     {
         update score but do not call (context.SaveChanges())
     }
}

 class Foo
 {
     public DoSomething(int update)
     {
           Score score = new Score();
           score.Update(2);
           SomeObj obj = (select object);
           obj.Soo = 3;
           context.SaveChanges();
      }
 }

基本上为了使它工作，我需要在方法Update中明确提供SaveChanges。但是当我有4个这样的方法，并且34243个用户想要更新数据时，我认为在4次旅行中为每个人保存是不错的。

在EF4.1中是否存在延迟数据库更新的最后时刻，在提供的示例中，或者我被迫明确保存每个方法？

编辑：为了澄清。我试图不在外部方法中调用SaveChanges，而只是保存更改的一次。

我将举一个真实的例子：

public class ScoreService : IScoreService
{
private JamiContext _ctx;
    private IRepository<User> _usrRepo;
    public ScoreService(IRepository<User> usrRepo)
    {
        _ctx = new JamiContext();
        _usrRepo = usrRepo;
    }

    public void PostScore(int userId, GlobalSettings gs, string name)
    {
        User user = _ctx.UserSet.Where(x => x.Id == userId).FirstOrDefault();
        if (name == "up")
        {
            user.Rating = user.Rating + gs.ScoreForLike;
        }
        else if (name == "down")
        {
            user.Rating = user.Rating - Math.Abs(gs.ScoreForDislike);
        }
    }
 }

现在：

public PostRating LikeDislike(User user, int postId, int userId, GlobalSettings set, string name)
    {
        PostRating model = new PostRating();
        var post = (from p in _ctx.PostSet
                    where p.Id == postId
                    select p).FirstOrDefault();
        if (name == "up")
        {
            post.Like = post.Like + 1;
            model.Rating = post.Like - post.Dislike;
        }
        else if (name == "down")
        {
            post.Dislike = post.Dislike + 1;
            model.Rating = post.Like - post.Dislike;
        }

        PostVote pv = new PostVote();
        pv.PostId = post.Id;
        pv.UserId = user.Id;
        _ctx.PostVoteSet.Add(pv);
        _scoreSrv.PostScore(userId, set, name);
        _ctx.SaveChanges();

        return model;
   }

我这个用户评级不会更新，直到我在PostScore中调用SaveChanges

Answer 1

在您的示例中，PostScore和LikeDislike使用不同的上下文实例。这是您的问题的根源，在这种情况下无法避免调用多个SaveChanges。整个操作是单个工作单元，因此它应该使用单个上下文实例。在这种情况下使用多个上下文实例是错误的设计。

无论如何，即使您调用单个SaveChanges，对于每个更新，插入或删除的实体，您仍然可以单独往返数据库，因为EF不支持命令批处理。

Answer 2

将数据库更新延迟到最后一刻的方法是在最后一刻之前不调用SaveChanges。

您可以完全控制此代码，如果您的代码在每次更新后调用SaveChanges，则需要更改。

Answer 3

这并不能解决我的整个问题，但至少我可以使用Context的单个实例：有了Ninject：

Bind<JamiContext>().To<JamiContext>().InRequestScope();

然后是构造函数：

private JamiContext _ctx;
    private IRepository<User> _usrRepo;
    public ScoreService(IRepository<User> usrRepo, JamiContext ctx)
    {
        _ctx = ctx;
        _usrRepo = usrRepo;
    }

实体框架4.1 - 一次旅行数据库更新

3 个答案: