Beginner on Dependency Injection

Question

So we have a class that does needs to output the result of an operation. Now this was tightly-coupled to emails, however with dependency injection I thought I could add more persistence options, eg. save to disk.

The problem is that saving to disk requires a path, while 'saving' as an email requires other details (from, to, etc).

Is this something that can be achieved through dependency injection? Or am I doing the whole thing wrong? Check code below and my comments to better understand my problem...

public class OriginalClass
{
    IPersistence _persistence;

    public OriginalClass(IPersistence persistence)
    {
        this._persistence = persistence;
    }

    public void DoSomething()
    {
        // I have all the information needed to send an email / save to disk. But how do I supply it?
        this._persistence.Put("Message to save");
    }
}

public interface IPersistence
{
    bool Put<T>(T data);
}

public class EmailPersistence : IPersistence
{
    public bool Put<T>(T data)
    {
        // How am I going to get the FROM and TO details?
        return EmailManager.Send("FROM", "TO", data.ToString());
    };
}

public class DiskPersistence : IPersistence
{
    public bool Put<T>(T data)
    {
        // How am I going to get the SAVE PATH details?
        // I just used a new initialization. So I'm probably doing this wrong as well...
        new System.IO.StreamWriter("SAVE PATH").Write(data.ToString());

        return true;
    }
}

Answer 1

Something like this should work, As now IEmailManager can also go via the DI framework, all you need to do is to bootstrap the EmailManager Construction.

   public class OriginalClass
{
    IPersistence _persistence;

    public OriginalClass(IPersistence persistence)
    {
        this._persistence = persistence;
    }

    public void DoSomething()
    {
        // I have all the information needed to send an email / save to disk. But how do I supply it?
        this._persistence.Put("Message to save");
    }
}

public interface IPersistence
{
    bool Put<T>(T data);
}

public class EmailPersistence : IPersistence
{
    private readonly IEmailManager _manager;

    public EmailPersistence(IEmailManager manager)
    {
        _manager = manager;
    }

    public bool Put<T>(T data)
    {
        // How am I going to get the FROM and TO details?
        return _manager.Send();
    }
}

public class EmailManager : IEmailManager
{
    public string From { get; set; }
    public string To { get; set; }


    public bool Send()
    {
        throw new NotImplementedException();
    }


    public dynamic Data { get; set; }

}

public interface IEmailManager
{
    string From { get; set; }
    string To { get; set; }

    dynamic Data { get; set; }
    bool Send();
}

public class DiskPersistence : IPersistence
{
    public string Path { get; set; }

    public DiskPersistence(string path)
    {
        Path = path;
    }

    public bool Put<T>(T data)
    {
        // How am I going to get the SAVE PATH details?
        // I just used a new initialization. So I'm probably doing this wrong as well...
        new System.IO.StreamWriter(Path).Write(data.ToString());

        return true;
    }
}

Answer 2

What you need to do is pass 'just enough' contextual information about the message to the persistence class. Passing on email-specific information like from and to however, causes you to leak implementation details of the persistence mechanism into OriginalClass, which is not something you should want. Doing this will cause you to have to change the OriginalClass everytime you add a new IPersistence implementation. This is obviously bad (it breaks both OCP and DIP).

So what exactly to supply is something only you can determine, but it could be something identifier that allows an implementation to retrieve the required information to operate. This could be something like the ID of the Contactperson or organization for who the message is written. This way you only have to pass in the message and this ID and the implementation can use this ID to query the database to get whatever it needs.

However, if these values do not change during the application's runtime, the solution is completely different. In that case you should simply use constructor injection:

public class EmailPersistence : IPersistence {
    private readonly MailAddress from;
    private readonly MailAddress to;
    public EmailPersistence(MailAddress from, MailAddress to) {
        this.from = from;
        this.to = to;
    }

    public bool Put(string data) {
        // How am I going to get the FROM and TO details?
        return EmailManager.Send(this.from, this.to, data.ToString());
    };
}

Since the settings do not change, you can load them from the config file (or from anywhere) during application startup and can simply create a new EmailPersistence using these fixed configuration values.