Is this Repository/UOW design workable?
Entity Framework already implements UoW+Repository for you.
To KISS, your code would simply &quot;wrap&quot; the DbContext with an interface, as explained here, here and here, and possibly elsewhere too. Shortly put: UoW+Repository is an abstraction. Entity Framework is an abstraction. Abstracting an abstraction by wrapping EF with UoW+Repository isn't going to KISS.
That said, there are a number of things to say about your code.


public interface IRepository&lt;T&gt;
{
    IEnumerable&lt;T&gt; GetAll();
}


That seems pretty.. naked. Limited, to say the least. What if you only need to fetch a single T? You're going to GetAll and filter them on the client side with Linq-to-Objects? Linq-to-Entities has much more to offer than that. I'd expect a repository interface to support all CRUD operations!
I don't understand why GenericRepository&lt;T&gt; doesn't implement IRepository&lt;T&gt;. Looks like you can get rid of the HostRepository class

If your entity type is a Host, then this is over-complicated:

var hosts = from host in context.Hosts
            select new Host()
            {
                FirstName = host.FirstName,
                LastName = host.LastName,
                Email = host.Email
            };                
return hosts.AsEnumerable().ToList();


It could be written like this:
return context.Hosts.ToList();

There's no need to project a selection of a given type into ..instances of that same type. There's no need to call AsEnumerable at all to return an IEnumerable&lt;T&gt;, because IQueryable&lt;T&gt; already implements IEnumerable&lt;T&gt;, which means this:
return context.Hosts;

Would return the same thing - the difference is when EF takes your query, translates it into T-SQL and sends it over to the database to materialize the results. You'll probably want to keep Linq-to-Entities within your DAL, which means you'll want to materialize the results before returning from the GetAll method - that's what ToList will do, so returning context.Hosts.ToList() is all you need to do here.

It's not clear why you're using internal, protected and virtual modifiers. A generic repository that needs to be inherited (virtual implies an eventual derived type that will override such a property/method), is missing its purpose I find - the very idea of having a generic repository is to avoid having to implement a repository for every entity type IMO.