What design pattern to use in this situation?

Question

I have 40 providers who need to connect to ftp, do something there and close the connection. Thus, all these 40 providers have their own class, and they all have ftp server connections and disconnections, but they all have different processing methods.

So basically, I have 40 classes using this method:

ftp.Connect();
//do something - this is different for all the classes
ftp.Close();

So, something else is different for everyone, it does different things, uses different variables, etc.

What I thought I would do was create a new class that will be created in all 40 providers. This class will have one method that looks something like this:

public void Connect(FTPCredentials credentials, Process process)
{
    var ftp = new FtpConnection(credentials.Host, credentials.Username, credentials.Password);
    ftp.Open();
    ftp.Login();

    process(ftp);

    ftp.Close();
}

public delegate void Process(FtpConnection ftp/*, string name*/);

, , , 40 , ? , , , ftp FtpConnection ftp, , DLL, FtpConnection , Connect.

, :

process(string fileName) //and it would download fileName
process(string folderName) //create folder if it doesnt exist

, , ?

Answer 1

, . , . mybirthname, , -:

public abstract class BaseSupplier
{
    protected BaseSupplier(FtpCredentials credentials)
    {
        _Credentials = credentials;
    }
    private FtpCredentials _Credentials;

    public void Run()
    {
        Connect();
        Process();
        Disconnect();
    }

    private void Connect() {/* your connection and login code */}
    private void Disconnect() {/* your disconnect code */}
    protected abstract void Process(); // to be filled in the derived class
}

public class ConcreteSupplier
{
    public ConcreteSupplier(FtpCredentials credentials, SomeType parameter) : base(credentials)
    { /* store extra parameters */ }

    override Process() {/*your concrete processing code */ }
}

, .

: juunas , . Gamma et al., Template Method " ".

Answer 2

    public abstract class BaseSupplier
    {

        public void Connect(FTPCredentials credentials, Process process, SupplierSettingClass settings)
        {
             var ftp = new FtpConnection(credentials.Host, credentials.Username, credentials.Password);
             ftp.Open();
             ftp.Login();

             DoSomething(settings);

             ftp.Close();
        }

        public virtual void DoSomething(SupplierSettingClass settings)
        {
             //define base case;
        }
    }

SupplierSettingClass, DoSomething (_, ..)

    public class SupplierSettingClass
    {
        public string FolderName {get; set;}

        //and so on;
    }

SupplierA

    public class SupplierA:BaseSupplier
    {
         public override void DoSomething(SupplierSettingClass settings)
         {
              //Do specific stuff for your class.
         }
    }

Answer 3

- , abstract, :

public interface IProcessor
{
    void Process(Credentials credentials);
}

public class Credentials
{
    public string Host { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
}

public abstract class SupplierBase : IProcessor, IDisposable
{
    protected FtpConnection _Connection;

    private void Connect(Credentials credentials)
    {
        //Create the ftp connection
        _Connection = new FtpConnection(credentials.Host, credentials.Username, credentials.Password);
        _Connection.Open();
        _Connection.Login();
    }

    private void Disconnect()
    {
        //Close and dispose the ftp connection
        _Connection.Close();
        _Connection.Dispose();
        _Connection = null;
    }

    public void Process(Credentials credentials)
    {
        Connect(credentials);
        Execute();
        Disconnect();
    }

    protected abstract void Execute();

    #region IDisposable

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (_Connection != null)
            {
                _Connection.Dispose();
                _Connection = null;
            }
        }
    }

    #endregion
}

public void MySupplier : SupplierBase
{
    //You can add unique supplier properties here.
    public string SomeProperty { get; set; }

    protected override void Execute()
    {
        //Implementation here
        Console.WriteLine(SomeProperty);
    }
}

, :

Credentials creds = new Credentials()
{
    Host = "127.0.0.1",
    Username = "test",
    Password = "test"
};

MySupplier sup1 = new MySupplier();
sup1.SomeProperty = "Hello";
sup1.Process(creds);

using (MySupplier sup1 = new MySupplier())
{
    sup1.SomeProperty = "Hello";
    sup1.Process(creds);
}