Creating a generic database context in MVC 4

It seems to me to what you're implementing is the Repository Pattern:

public interface IRepository<TEntity> where TEntity : class
{
    IEnumerable<TEntity> GetAll();

    TEntity GetById(Guid id);
}

Prevent letting your repository inherit from DbContext, since DbContext is an implementation of the Unit of Work pattern and a unit of work is not a repository (but rather contains or manages multiple repositories).

What you can do is to let your repository use the DbContext internally:

public class Repository<TEntity> : IRepository<TEntity>
{
    private readonly DbContext context;

    public Repository(DbContext context)
    {
        this.context = context;
    }

    public IEnumerable<TEntity> GetAll()
    {
        return this.context.Set<TEntity>();
    }

    public TEntity GetById(Guid id)
    {
        var entity = this.context.Set<Entity>().Find(id);

        if (entity == null) throw new KeyNotFoundException(
            typeof(TEntity).Name + " with id " + id + " not found);

        return entity;
    }
}

UPDATE

Since I'm a Dependency Injection enthusiast, I think that Dependency Injection is the solution to your problem. And since I'm a developer for the Simple Injector project, I'll show you how to do this using Simple Injector:

Step 1: Install the Simple Injector MVC Integration Quick Start NuGet package into your MVC project (I assume you know how to install NuGet packages).

Step 2: Compile your project. You'll get a compiler error in the SimpleInjectorInitializer class that the package just added. This is the line where you will have to make your registrations. You can just remove this #error line.

Step 3: Add the SimpleInjector.Extensions namespace to the top of the SimpleInjectorInitializer file:

using SimpleInjector.Extensions;

Step 4: Make the following registrations in the InitializeContainer method:

container.RegisterOpenGeneric(typeof(IRepository<>), typeof(Repository<>));

container.RegisterPerWebRequest<DbContext>(
    () => new DbContext("Your connection string here"));

Step 5: Add the IRepository<T> dependencies to your contollers:

public class CustomerController : Controller
{
    private readonly IRepository<Customer> customerRepository;

    public CustomerController(IRepository<Customer> customerRepository)
    {
        this.customerRepository = customerRepository;
    }

    // controller methods here.
}

Now your repositories will be automatically be injected into your controllers.

Is there a reason you want to make a DatabaseContext with a generic type parameter? You won't be to instantiate it in a single place because each different DatabaseContext is a separate .NET Type.

Unless you're sticking rigidly to a particular pattern, I personally don't see any practical advantage of this approach over a single DatabaseContext with many sets:

public class DatabaseContext: DbContext
{
    public DbSet<SomeEntity> SomeEntities { get; set; }
    public DbSet<OtherEntity> OtherEntities { get; set; }
}

...
myDatabaseContext.SomeEntities.GetAll();
myDatabaseContext.OtherEntities.GetAll();

// OR:
myDatabaseContext.Set<SomeEntity>().GetAll();
myDatabaseContext.Set<OtherEntity>().GetAll();