C#

Edit: Thanks to Eddy Vluggen, and Freak30, problem resolved. The solution was that I needed to create a separate .dll containing only the Interface, and then have both the host application, and the dynamically loaded UserControl, reference the Interface .dll.

1. Assembly LoadedAssembly = Assembly.LoadFile(... filePath to usercontrol .dll ...);

2a. Type LoadedIInterfaceType = LoadedAssembly.GetTypes()[0]; // get the Type of the Interface
2b. Type LoadedUCType = LoadedAssembly.GetTypes()[1]; // get the Type of the UserControl

3. UserControl loadedUC = (UserControl)Activator.CreateInstance(LoadedUCType);

// example
interface Iinterface
{
   // some public property in the UserControl
   // which is implemented in the UserControl
   string ID { set; get; }
}

var methods = LoadedIInterfaceType .GetMethods();
var types = LoadedIInterfaceType .GetProperties();
var fields = LoadedIInterfaceType .GetFields();

public class Product : BaseEntity
{
   public int ProductId { get; set; }
   public string ProductName { get; set; }
}

public interface IDbContext : IDisposable
{
    IDbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity;
}

public class MyObjectContext : DbContext, IDbContext
{
    public new IDbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity
    {
        return base.Set<TEntity>();
    }
}

public interface IDbContextFactory
{
    Lazy<IDbContext> CreateDbContext();
}

public class MyDbContextFactory : IDbContextFactory
{
    public MyDbContextFactory(string dbConnectionString)
    {
        _dbConnectionString = Settings.DbConnectionString;
        _dbContext = CreateDbContext();
    }

    public IDbContext CreateDbContext()
    {
        IDbContext dbContext = new IDbContext(() => CreateNewContext());
        return dbContext;
    }

    private MyObjectContext CreateNewContext()
    {
        return new MyObjectContext (_dbConnectionString);
    }
}

public partial interface IRepository<T> where T : BaseEntity
{
    T GetById(object id);
}

public partial class EfRepository<T> : IRepository<T> where T : BaseEntity
{
    private readonly Lazy<IDbContext> _dbContext;
    private readonly IDbContextFactory _dbContextFactory;
    private readonly Lazy<ObjectStateManager> _objectStateManager;

    public EfRepository(IDbContextFactory dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
        _dbContext= _dbContextFactory.CreateDbContext();
        _objectStateManager= new Lazy<ObjectStateManager>(() => ((IObjectContextAdapter)_dbContext.Value).ObjectContext.ObjectStateManager);
    }

    public T GetById(object id)
    {
        return this.Entities.Find(id);
    }
}

public CountryController(Lazy<IRepository<Country>> countryRepository)
    {
        _countryRepository = countryRepository;
    }

    public Country GetCountryById(int id)
    {
        Country country = _countryRepository.Value.GetByIdNonProxiedAsync(id);

        if (country != null)
            return country;
        else
            return null;
    }

IDBContext -> IDBContextFactory -> IRepository <T>