在WPF应用程序中管理DbContext

Question

I am currently working on a WPF application using .NET 4.6. We are using the Entity Framework for Persistence and Database interaction with SQL Server. When I joined the project all the database interaction was being done in the code behind like the following. (Yes I realize this is bad practice)

IList<User> users;
using (AppDbContext db = new AppDbContext())
{
    users = db.Users.Where(x => x.Active == true).ToList();
}

// do code to update UI

I basically said this is bad practice, we need to separate out the business logic and queries from the presentation layer. I thought the Repository pattern might be a nice place to start but I have doubts about how the DbContext will be managed.

Example Repository Interface

public interface IUserService : IDisposable
{
    IList<applicationuser> GetUsers();
    IList<AllApplicationUser> GetActiveUsers();
    AllApplicationUser GetUserView(long id);
    applicationuser GetUser(long id);
    void CreateUser(applicationuser user);
    void UpdateUser(applicationuser user);
    void DeleteUser(long id);
    void Save();
    applicationuser Authenticate(string username, string password);
}

And the implementation

class UserService : IUserService
    {
        private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
        private readonly OMEGAEntities _db;
        private bool _disposed = false;

        public UserService()
        {
            _db = new OMEGAEntities();
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    _db.Dispose();
                }
            }
            _disposed = true;
        }

        public IList<applicationuser> GetUsers()
        {
            // fetch only active users that do not have the role SuperAdmin
            return _db.applicationusers.Where(u => u.roleid != 1 && u.activeflag == true).ToList();
        }

        public IList<AllApplicationUser> GetActiveUsers()
        {
            return _db.AllApplicationUsers.Where(u => u.activeflag == true && u.roleid != 1).ToList();
        }

        public AllApplicationUser GetUserView(long id)
        {
            return _db.AllApplicationUsers.Single(x => x.id == id);
        }

        public applicationuser GetUser(long id)
        {
            return _db.applicationusers.Find(id);
        }

        public void CreateUser(applicationuser user)
        {
            _db.applicationusers.Add(user);
        }

        public void UpdateUser(applicationuser user)
        {
            _db.Entry(user).State = EntityState.Modified;
        }

        public void DeleteUser(long id)
        {
            var user = _db.applicationusers.Find(id);
            _db.applicationusers.Remove(user);
        }

        public void Save()
        {
            _db.SaveChanges();
        }

        public applicationuser Authenticate(string username, string password)
        {
            applicationuser user =
                _db.applicationusers.SingleOrDefault(u => u.loginid.ToLower().Equals(username.ToLower()));

            if (user != null)
            {
                if (Common.Utils.DecryptData(user.password).Equals(password))
                {
                    return user;
                }          
            }

            return null;
        }
    }

The issue now is when there are multiple windows open there are multiple contexts open and long running contexts. One of the ideas floating around right now is to use a single context for the entire application, since it is a single user desktop application, however that doesn't seem like the best idea. Also the dbContexts need to be disposed off when the windows are closing, etc.

I've read about the idea of using a DbContext per request in ASP.NET. Maybe one could be used per Window?

I'm just wondering if the repository pattern is the best way for WPF applications? I've seen many people have success with it in ASP.NET.

Answer 1

You could create a sort of unitofwork on top of your repositories, and contructor inject the dbcontext into the repositories

public class UnitOfWork : IUnitOfWork
{
    private IUserService userService;
    private omegaentities dbcontext;
    public UnitOfWork ()
    {
    dbcontext = new Omegaentities ();
    }
    public IUserService UserService {
    get {
             If (userService == null)
             { userService = new UserService(dbcontext);}

    Return userService;
    }

}

Then you just call

unitOfWork.UserService.GetUsers();

... This gives one more layer of abstraction, you still need to handle the single instance of unitofwork, but that can be handled nicely with some DI magic :)

Note: i wrote this from the android app! (Coding c# on a phone, does not rock!)

Answer 2

It really depends on how you use your DbContext. If you are reading some data could be changed by some other application, I would suggest use disposable DbContext every time. If you are sure your application is the only one to touch the database, then keep a single DbContext in your repository and use a singleton repository across the entire application.