public class User : IEntity, IReturnType
{
     public long Id { get; set; }
     public string FirstName { get; set; }
     public string LastName { get; set; }
     public DateTime Dob { get; set; }
     public bool IsActive { get; set;  }
}

public class Product : IEntity, IReturnType
{
//properties...
}

public class UserService
{
   //UserService doesn't know about real repos class however it knows those three guys can do csv, sqlserver, oracle operations
   //private readonly ICsvRepo<User> _csvSource;
   //private ISqlServerRepo<User> _sqlServerSource;
   //private IOracleRepo<User> _oracleSource;


    public UserService()
    {
         //like factory for all concrete repos
         var kernel = new StandardKernel(new RepoModule("foo", "bar")); /*some other modules here maybe?*/

         //IoC ensure to get concrete object like factory however UserService doesn't know it
           var csvSource = kernel.Get<ICsvRepo<User>>();
           //use things
           csvSource.GetAll();
           csvSource.GetByLine();

            //IoC ensure to get concrete object like factory however UserService doesn't know it
            var sqlRepo = kernel.Get<ISqlServerRepo<User>>();
            //use things
            sqlRepo.GetAll();
            sqlRepo.GetById(34);

            //IoC ensure to get concrete object like factory however UserService doesn't know it
            var oracleManager = kernel.Get<IOracleRepo<User>>();
            //use things
            oracleManager.GetAll();
            oracleManager.GetById(34);


        }
}

public interface IRepo { }

    public interface IRepoX : IRepo { }

    public interface IRepositoryDatasource<out T> : IRepo where T : IGeneric
    {
        IEnumerable<T> GetAll();
    }

    public interface ICsvRepo<out T> : IRepositoryDatasource<T> where T : IReturnType
    {
        IEnumerable<T> GetByLine();
    }

    public interface IDatabaseRepo<T> : IRepositoryDatasource<T> where T : IEntity
    {
        T GetById(int id);
        T GetByName(string name);
        void Add(T entity);
        void Delete(T entity);
    }

    public interface IOracleRepo<T> : IDatabaseRepo<T> where T : IEntity
    {
        //add more concrete to Oracle database if needed
    }

    public interface ISqlServerRepo<T> : IDatabaseRepo<T> where T : IEntity
    {
        //add more concrete to Sql Server database if needed
    }

    public interface ICsvSettings
    {
        string Path { get; }
        string FileName { get; }
    }

    public interface ISqlSettings
    {
        string ConnectionString { get; }
        string Username { get; }
        string Password { get; }
    }

    internal class CsvSettings : ICsvSettings
    {
        public string Path { get; set; }
        public string FileName { get; set; }
    }

    internal class SqlSettings : ISqlSettings
    {
        public string ConnectionString { get; set; }
        public string Username { get; set; }
        public string Password { get; set; }
    }

    internal class OracleRepo<T> : IDatabaseRepo<T> where T : IEntity
    {
        private readonly ISqlSettings _settings;
        private readonly IRepoX _repoX;

        public OracleRepo(ISqlSettings settings, IRepoX repoX)
        {
            _settings = settings;
            _repoX = repoX;
        }

        public IEnumerable<T> GetAll()
        {
            throw new NotImplementedException();
        }

        public T GetById(int id)
        {
            throw new NotImplementedException();
        }

        public T GetByName(string name)
        {
            throw new NotImplementedException();
        }

        public void Add(T entity)
        {
            throw new NotImplementedException();
        }

        public void Delete(T entity)
        {
            throw new NotImplementedException();
        }
    }

    internal class SqlServerRepo<T> : IDatabaseRepo<T> where T : IEntity
    {
        private readonly ISqlSettings _settings;
        private readonly IRepoX _repoX;

        public SqlServerRepo(ISqlSettings settings, IRepoX repoX)
        {
            _settings = settings;
            _repoX = repoX;
        }

        public IEnumerable<T> GetAll()
        {
            throw new NotImplementedException();
        }

        public T GetById(int id)
        {
            throw new NotImplementedException();
        }

        public T GetByName(string name)
        {
            throw new NotImplementedException();
        }

        public void Add(T entity)
        {
            throw new NotImplementedException();
        }

        public void Delete(T entity)
        {
            throw new NotImplementedException();
        }
    }

    internal abstract class CsvRepo<T> : ICsvRepo<T> where T : IReturnType
    {
        protected readonly ICsvSettings Settings;

        protected CsvRepo(ICsvSettings settings)
        {
            Settings = settings;
        }

        public virtual IEnumerable<T> GetAll()
        {
            throw new NotImplementedException();
        }

        public virtual IEnumerable<T> GetByLine()
        {
            throw new NotImplementedException();
        }

        //public abstract IEnumerable<T> GetRecordsFromFile();
    }

    //more concrete repository class uses concrete InputData1
    //this is because at CsvRepo was not possible to Yield IEntity... because at this
    //point we dont know what to return InputData1, InputData2 etc.. therefire inheritance solve that issue
    internal class ReturnTypeAbcCsvRepo : CsvRepo<ReturnTypeAbc>
    {
        public ReturnTypeAbcCsvRepo(ICsvSettings settings) : base(settings)
        {
        }

        public override IEnumerable<ReturnTypeAbc> GetAll()
        {
            return from line in File.ReadLines(Settings.Path)
                   select line.Split(',') into parts
                   where parts.Length == 3
                   select new ReturnTypeAbc { A = Convert.ToInt32(parts[0]), B = Convert.ToInt32(parts[1]), C = Convert.ToInt32(parts[2]) };
        }
    }

    internal class ReturnTypeXyzCsvRepo : CsvRepo<ReturnTypeXyz>
    {
        public ReturnTypeXyzCsvRepo(ICsvSettings settings) : base(settings)
        {
        }
        public override IEnumerable<ReturnTypeXyz> GetAll()
        {
            return from line in File.ReadLines(Settings.Path)
                   select line.Split(',') into parts
                   where parts.Length == 3
                   select new ReturnTypeXyz { X = Convert.ToInt32(parts[0]), Y = Convert.ToInt32(parts[1]), Z = Convert.ToInt32(parts[2]) };
        }
    }
}

internal class RepoX : IRepoX { }

public class RepoModule : NinjectModule
{
    private readonly string _username;
    private readonly string _password;
    public RepoModule(string username, string password)
    {
        _username = username;
        _password = password;
    }
    public override void Load()
    {
        Bind<ICsvSettings>().ToConstant(new CsvSettings
        {
            FileName = "foo",
            Path = Config.Instance.ServerName,
        }).InSingletonScope();

        Bind<ISqlSettings>().ToConstant(new SqlSettings
        {
            ConnectionString = "foo",
            Password = _password,
            Username = _username
        }).InSingletonScope();



        Bind<IRepoX>().To<RepoX>();

        Bind(typeof(ICsvRepo<ReturnTypeAbc>)).To(typeof(ReturnTypeAbcCsvRepo));
        Bind(typeof(ICsvRepo<ReturnTypeXyz>)).To(typeof(ReturnTypeXyz));

        Bind(typeof(ICsvRepo<>)).To(typeof(CsvRepo<>));


        Bind(typeof(IOracleRepo<>)).To(typeof(OracleRepo<>));
        //Bind(typeof(IOracleRepo<>)).To(typeof(OracleRepo333<>));
    }
}


public interface IGeneric
{

}

public interface IEntity : IGeneric
{
}

public interface IUserEntity : IEntity
{

}

public interface IProductEntity : IEntity
{

}

public interface IReturnType : IGeneric
{
}

public interface IReturnTypeAbc : IReturnType
{
    int A { get; set; }
    int B { get; set; }
    int C { get; set; }
}

public interface IReturnTypeXyz : IReturnType
{
    int X { get; set; }
    int Y { get; set; }
    int Z { get; set; }
}

public class ReturnTypeAbc : IReturnTypeAbc
{
    public int A { get; set; }
    public int B { get; set; }
    public int C { get; set; }
}

public class ReturnTypeXyz : IReturnTypeXyz
{
    public int X { get; set; }
    public int Y { get; set; }
    public int Z { get; set; }
}

UserService
ProductService

public class DbManager : IDbManager
    {
        private readonly DatabaseHelper _database;

        public DbManager(string connectionStringName)
        {
            _database = new DatabaseHelper(connectionStringName);
        }

        public IDbConnection GetDatabasecOnnection()
        {
            return _database.GetConnection();
        }

        public void CloseConnection(IDbConnection connection)
        {
            _database.CloseConnection(connection);
        }

        public IDbDataParameter CreateParameter(string name, object value, DbType dbType)
        {
            return _database.GetParameter(name, value, dbType, ParameterDirection.Input);
        }

        public IDbDataParameter CreateParameter(string name, int size, object value, DbType dbType)
        {
            return _database.GetParameter(name, value, dbType, size, ParameterDirection.Input);
        }

        public IDbDataParameter CreateParameter(string name, int size, object value, DbType dbType, ParameterDirection direction)
        {
            return _database.GetParameter(name, value, dbType, size, direction);
        }

        public DataTable GetDataTable(string commandText, CommandType commandType, IDbDataParameter[] parameters = null)
        {
            using (var connection = _database.GetConnection())
            {
                using (var command = _database.GetCommand(commandText, connection, commandType))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }

                    var dataset = new DataSet();
                    var dataAdaper = _database.GetDataAdapter(command);
                    dataAdaper.Fill(dataset);

                    return dataset.Tables[0];
                }
            }
        }
//other database methods ...
}

IDbManager dbManager = new DbManager("mysql");

            var user = new User
            {
                FirstName = "First",
                LastName = "Last",
                Dob = DateTime.Now.AddDays(-3000),
                IsActive = true
            };

        var parameters = new List<IDbDataParameter>
            {
                dbManager.CreateParameter("@FirstName", 50, user.FirstName, DbType.String),
                dbManager.CreateParameter("@LastName", user.LastName, DbType.String),
                dbManager.CreateParameter("@Dob", user.Dob, DbType.DateTime),
                dbManager.CreateParameter("@IsActive", 50, user.IsActive, DbType.Boolean)
            };

       long lastId;


            dbManager.Insert("DAH_User_Insert", CommandType.StoredProcedure, parameters.ToArray(), out lastId);
            Console.WriteLine("nINSERTED ID: " + lastId);

 //DATATABLE
            dataTable = dbManager.GetDataTable("DAH_User_GetAll", CommandType.StoredProcedure);
            Console.WriteLine(
                $"nUPADTED VALUES FirstName: {dataTable.Rows[0]["FirstName"]} LastName: {dataTable.Rows[0]["LastName"]}");