Implementing a generic class and choosing a collection based on a type
It seems like you could just mirror the way FetchFromDatabase is implemented. First thing you will need is a something like a DbContext, but for collections. This new class should be capable of returning an IEnumerable&lt;TEntity&gt; for any TEntity defined -- just like DbContext.

public class CollectionContext
{
    private Dictionary&lt;Type, object&gt; _cache;

    public CollectionContext()
    {
        _cache = new Dictionary&lt;Type, object&gt;();
    }

    public void AddCollection&lt;TEntity&gt;(IEnumerable&lt;TEntity&gt; collection)
    {
        _cache.Add(typeof(TEntity), collection);
    }

    public IEnumerable&lt;TEntity&gt; Set&lt;TEntity&gt;()
    {
        return (IEnumerable&lt;TEntity&gt;)_cache[typeof(TEntity)];
    }
}


Now FetchFromCollection can be implemented exactly like FetchFromDatabase, with exception of the type used in the constructor. 

public class FetchFromCollection&lt;TEntity&gt; : IFetchData&lt;TEntity&gt;
where TEntity : class
{
    private readonly CollectionContext context;

    public FetchFromCollection(CollectionContext context)
    {
        if (context == null)
            throw new ArgumentNullException("Collection context");
        this.context = context;
    }

    public IEnumerable&lt;TEntity&gt; GetItems()
    {
        return context.Set&lt;TEntity&gt;();
    }
}


This is how you'd use it.

// Load up all your collections
var context = new CollectionContext();
context.AddCollection&lt;Module&gt;(new ModelModules(components).Set());
context.AddCollection&lt;Specialization&gt;(new ModelSpecializations(components).Set());
context.AddCollection&lt;Teacher&gt;(new ModelTeachers(components).Set());

// Example usage
IFetchData&lt;Module&gt; modules = new FetchFromCollection&lt;Module&gt;(context);


I think you can further improve on your design by getting rid of the generic type parameter on FetchFromDatabase and FetchFromCollection. Each of these classes is capable of pulling any TEntity out of their contexts'. By making this change you'd only need to have one instance of FetchFromDatabase and FetchFromCollection for your entire application, instead of one instance of each for every TEntity. You can just move the generic type parameter down to GetItems(). This same change would need to be made to IFetchData. Here is an example for FetchFromCollection, the same change can be made to FetchFromDatabase:

public class FetchFromCollection : IFetchData
   {
    private readonly CollectionContext context;

    public FetchFromCollection(CollectionContext context)
    {
        if (context == null)
            throw new ArgumentNullException("Collection context");
        this.context = context;
    }

    public IEnumerable&lt;TEntity&gt; GetItems&lt;TEntity&gt;()
    {
        return context.Set&lt;TEntity&gt;();
    }
}