Question

I have a occasionally connected application where there is a server that stores information about products. I am using a database cache to store this information locally so when a connection is unavailable the application will still work when trying to read the database.

Since the database is configured and I do not have access to modify the tables, I did not implement 2 way updating and it only downloads a snapshot. A side question is if it is possible to create a database cache and have 2-way sync with only tracking columns on the client machine? I cannot add any columns or tables to the server. I know this might be a question for a separate post, but if this is true then it would change my direction for this problem completely, to a separate module detecting and syncing the database and handling any sync errors that are thrown and always connecting to the cache.

I am using a generic repository and I am wondering what the best practice to go about handling if a connection is available or not and using either a local or remote database depending on this status.

Should I add an interface to the generic repository that handles returning the correct string, and lets the repository know if it is live or not? I need to enable/disable certain features depending on the connection state so I also will need a property somewhere so that when this repository is used there can be a way to bind various controls enabled state to this status.

Instead should I have a wrapper that contains for example an IRepository and IConnectionStringManager and then handles feeding and initializing the repository connection string based on availability? This wrapper would expose the repository and any status properties required.

I guess I am not sure if I should be setting up my program to use IRepository with all the automatic connection sensing behind the scenes, or if I should have IRepositoryManager that has a IRepository and IConnectionStringManager in it.

Maybe both of those options are wrong?

Answer 1

I like the way Entity Framework allows you to provide a connection string as a constructor argument to its contexts. That way you can leverage a dependency injection framework to apply special logic when creating the context, and you only have to change the code in one place (assuming you’re using DI principles). You could do something similar with your repository implementation.

Update

Since you’re using Entity Framework, here’s an idea of what it might look like in code:

// DI Bindings, Ninject style
Bind<Func<MyContext>>().ToMethod(
    c => new MyContext(
             c.Kernel.Get<IConnectionManager>().IsOnline()
                 ? OnlineConnectionString 
                 : OfflineConnectionString));

// Usage
public class ThingRepository : IThingRepository 
{
    private Func<MyContext> _getContext;
    public ThingRepository(Func<MyContext> getContext)
    {
        _getContext = getContext;
    }

    public IEnumerable<Thing> GetAllThings()
    {
        using(var context = _getContext())
        {
            return context.Things.ToList();
        }
    }
}

Or, if you prefer to use a more explicit factory implementation:

public interface IMyContextFactory
{
    MyContextFactory Get();
}

public class MyContextFactory : IMyContextFactory
{
    private const string OnlineConnectionString = "...";
    private const string OfflineConnectionString = "...";
    private IConnectionManager _connectionManager;
    public MyContextFactory(IConnectionManager connectionManager)
    {
        _connectionManager = connectionManager;
    }
    public MyContextFactory Get() 
    {
        var connectionString = _connectionManager.IsOnline() 
            ? OnlineConnectionString 
            : OfflineConnectionString
        return new MyContext(connectionString);
    }
}

// DI Bindings, Ninject style
Bind<IMyContextFactory>().To<MyContextFactory>();

// Usage
public class ThingRepository : IThingRepository 
{
    private IMyContextFactory _myContextFactory;
    public ThingRepository(IMyContextFactory myContextFactory)
    {
        _myContextFactory = myContextFactory;
    }

    public IEnumerable<Thing> GetAllThings()
    {
        using(var context = _myContextFactory.Get())
        {
            return context.Things.ToList();
        }
    }
}