Pass specific information to concrete classes in appropiate way

Question

I have question regarding passing by some information to my repositories classes. Currently I have two repositories, CsvRepository and SqlRepository. For both of them, I want to pass some information, currently there is only path to be passed for CsvRepository. As you can see I also have factory pattern class and GetRepository method to get specific object on demand. I do not think this is right place to pass that information from CsvRepository method because it's not the duty of factory method. Could you help me out where this should be passed correctly?

 public enum DataSource
    {
        SqlServer,
        Csv,
        Oracle
    }

    public interface IRepo
    {
    }

    public interface IRepository<T> : IRepo where T : class
    {
        IEnumerable<T> GetRecords();
    }

    public class RepositoryFactory
    {
         // here I would need to pass all information for all repositories - bad idea perhaps
         public static IRepo GetRepository(DataSource repositoryType)
         {
             IRepo repo;

             switch (repositoryType)
             {
                  case DataSource.Csv:
                     repo = new CsvRepository("path"); //perhaps path shouldn't be right passed right here - so where?
                     break;

                  case DataSource.SqlServer:
                     repo = new SqlRepository();
                     break;

                  default:
                     throw new ArgumentException("Invalid Repository Type");
             }

             return repo;
        }
    }

    public class CsvRepository : IRepository<InputData>
    {
          private string _path;

          public CsvRepository(string path)
          {
               _path = path;
          }

          public IEnumerable<IBasic> GetRecords()
          {
              return from line in File.ReadLines(_path)
                  select line.Split(',') into parts
                  where parts.Length == 3
                  select new InputData { Name = parts[0], X = Convert.ToInt32(parts[1]), Y = Convert.ToInt32(parts[2]) };
          }
    }

    // other repository
    public class OracleRepository : IRepository<InputData>
    {
        // to be implemented
    }

    class Form1
    {  
         private void FetchData(DataSource repositoryType)
         {
              ClearListBox();

              var repository = RepositoryFactory.GetRepository(repositoryType);
              var people = repository.GetRecords();
         }

         private void CSVFetchButton_Click(object sender, RoutedEventArgs e)
         {
              FetchData(DataSource.Csv);
         }

    private void SQLFetchButton_Click(object sender, RoutedEventArgs e)
    {
        FetchData(DataSource.SqlServer);
    }

    public class InputData : IBasic
    {
        public string Name { get; set; }
        public int X { get; set; }
        public int Y { get; set; }
    }

public interface IBasic
{
}

Answer 1

Usually, when your factory needs parameters for concrete implementations - you split factories in two. One with additional parameters and one without it. One of good options is to define interface for factory and create two methods:

public interface IRepoFactory
{
    IRepo GetRepository(DataSource repositoryType);
    IRepo GetRepository(DataSource repositoryType, /*a ton of informations here*/);
}

On the other hand, I always prefer to split interfaces. Read bellow as to why. BUT, lets first look at what kind of parameters you can pass.

Parameters binded to lifetime of IRepo instance, should be passed in Create method and usually inside constructor, there is no exceptions, for example if you have multiple SQL servers:

public interface IRepoFactory
{
    IRepo GetRepository(string connectionString); //you can specify here concrete SQL server
    IRepo GetTestRepository(string folder); //for example you want to unit test on different folders
}

Parameters binded to lifetime of IRepoFactory, should be passed in factory constructor, because they will be active during entire lifetime of factory (usually it is also lifetime of Application, because factories often used as singletons). For example, you have single SQL server, and don't care what repository is created and to where it is connected:

public interface IRepoFactory
{
    IRepo GetRepository(); //you don't care about SQL server at all
    IRepo GetTestRepository(); //you don't care where test environment allocated
}

public class MyRepoFactory : IRepoFactory
{
    public MyRepoFactory(string connectionString)
    {
       //...
    }

    //implementation
}

So, I split them, because of parameter lifetimes. At one point you will clearly see, that CsvRepository don't care about SQL connection string but it care about path it is located at. These functionality created dependand on different things and these things have their own lifetimes and so should be split into different factories.

How to manage a ton of those interfaces? Well, factory pattern will not help with these. But IoC pattern will do, and I insist to read it because you can call it somewhat "mainstream" of production development, which has many aplications at testing/refactoring/dependencies management. Read more here.

As to your question, do these steps:

1. Choose lifetime for you additional parameters
2. Choose first or second or both approach described
3. Split your factory in two, if you see they become too overloaded with functionality
4. Use one of the two IoC pattern implementations to manage your lifetimes and dependencies of those parameters: Service Locator or Dependency Injection (I prefer DI, it is more strict approach)

EDIT realted to IoC usage:

Here is example of how it usually done in Ninject:

public interface IRepo { }
public interface IRepository<T> : IRepo where T : class {}

public interface ICsvRepo<T> : IRepository<T> where T : class { }
public interface ISqlRepo<T> : IRepository<T> where T : class { }
public interface IOracleRepo<T> : IRepository<T> where T : class { }

public interface IRepoX : IRepo { }

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 CsvRepo<T> : ICsvRepo<T> where T : class
{
    private readonly ICsvSettings _settings;
    public CsvRepo(ICsvSettings settings)
    {
        _settings = settings;
    }
}

internal class SqlRepo<T> : ISqlRepo<T> where T : class
{
    private readonly ISqlSettings _settings;
    private readonly IRepoX _repoX;

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

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

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

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 = "bar"
        }).InSingletonScope();

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

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

        Bind(typeof(ICsvRepo<>)).To(typeof(CsvRepo<>));
        Bind(typeof(ISqlRepo<>)).To(typeof(SqlRepo<>));
        Bind(typeof(IOracleRepo<>)).To(typeof(OracleRepo<>));
    }
}

And then in your application you do this:

class Program
{
    static void Main(string[] args)
    {
        var kernel = new StandardKernel(new RepoModule("foo", "bar"), /*some other modules here maybe?*/);

        //thousand of code lines later...

        var csvRepo = kernel.Get<ICsvRepo<MyEntity>>();
        var data = FetchData(csvRepo);

        var sqlRepo = kernel.Get<ISqlRepo<MyEntity>>();
        data = FetchData(sqlRepo);

        var oracleRepo = kernel.Get<IOracleRepo<MyEntity>>();
        data = FetchData(oracleRepo);
    }

    static T[] FetchData<T>(IRepository<T> repo)
    {
        throw new NotImplementedException();
    }
}

You can wrap it into factory if you want, but at this point it is not neccesary (you implemented factory on IoC container)

Answer 2

Using IOC would be ideal - inject all the repository types and let the container resolve their dependencies, but you could start simpler with a Settings class that contains all the App settings (implementing ISettingsSql, ISettingsCsv, ...) and pass it into your factory so that each repo can get its paths. –

e.g.

Constructor for CsvRespository:

  public CsvRepository(ISettingsCsv settings)
  {
       _path = settings.CsvPath;
  }

Constructor for SqlRepository:

  public SqlRepository(ISettingsSql settings)
  {
       _connectionString = settings.SqlConnectionString;
  }

Next, wrap all these up in an overall settings interface:

  public interface ISettings : ISettingsSql, ISettingsCsv, ...
  {
  }

And now you can implement:

  public class Settings : ISettings
  {
     public string CsvPath {get; set;}
     public string SqlConnectionString {get; set;}
     ...
  }

Create an instance of that class with all your settings in it:

  var settings = new Settings { CsvPath = "...", ... };

And now you can inject that into your factory where it can be used by the factory method:

 public class RepositoryFactory
 {
    ISettings settings;
    public RepositoryFactory (ISettings settings)
    {
       this.settings = settings;
    }

    ...

   public IRepo GetRepository(DataSource repositoryType)
   {
      ...
          return new CsvRepository(this.settings);
   }

The next step would be to use a container to register all repositories and then resolve them as a collection IEnumerable<IRepo> allRepos and change the factory to find the repo that can match the enum (expose the enum on each repo class) and use a loop or a dictionary. The switch statement can then go away. When you do that, each repo will try to resolve its own ISettingsXXX dependency and so on.