[Leia sobre] C# - Usando Interfaces para garantir baixo acoplamento!

C# - Usando Interfaces

//Usando interfaces para garantir baixo acoplamento
//Foi Criando um botão para executar alguma ação dentro do windows Forms;
//Vai notar que, nesse caso, as implementações dos métodos não mais utilizam a palavra public.
//Deste modo, só poderá fazer o acesso aos métodos, via interface:
    public partial class Form1 : Form
    {
ISampleInterface obj = new ImplementationClass();
private void button3_Click(object sender, EventArgs e)
{
string strlogEnviar = "Error: \n Ocorreu um Erro Ao Executar um Arquivo \n";
callintefacechamando = obj.criarArquivoLogs(strlogEnviar);
MessageBox.Show("Recebido da Interface: \n" + callintefacechamando);
}
}
// Classe da implementação da interface, que definidas pode ser feita da seguinte forma pela classe concreta ISampleInterface:
   interface ISampleInterface
    {
        //aqui estou criando uma metodo da interface
        object criarArquivoLogs(string strlogEnviar);
    }
// A classes concreta implementa o método criarArquivoLogs() definidos nas interfaces e ao implementar a interface na classe temos uma classe de implementação de arquivo de log;
//Assim a classe que implementa a interface deve implementar todos os seus métodos ou ser uma classe Abstrata;
    class ImplementationClass : ISampleInterface
    {
public object retorno { get; set; }
object ISampleInterface.criarArquivoLogs(string strlogEnviar)
{
return retorno = CriarArquivoLog.criarArquivoLogsnovo(strlogEnviar);
}
}
//Podemos citar algumas pequenas diferenças:
//Classe abstrata
// Pode ter ou não alguma implementação. Pode também ter variáveis membros, métodos não abstratos ou propriedades.
// Pode derivar de apenas uma classe base, mesmo que essa classe base seja abstrata, mas pode derivar de quants interfaces for necessario.
// Pode ter métodos e propriedades não publicos, ou seja, private ou protected.
// Pode ter métodos e membros estaticos (static) e definir constantes.

//Interface
// Não tem implementações ou váriaveis membros.
// Só pode derivar de interfaces.
// Todos os membros são publicos.
// Não pode ter nenhum desses items.

// classe para criação do arquivo de log;
    class CriarArquivoLog
    {
        // implementação de arquivo de log com interface...
        public string path = @"C:\temp\teste_Inplementacao.log"; // local onde vai gravar o log,
        private FileStream arquivo;  // arquivo que vai ser criando pele filestream
        private static CriarArquivoLog log;  // aqui esta instanciando a o log.
        public static object retorno { get; set; }
        internal static object criarArquivoLogsnovo(string strlogEnviar)
        {
            retorno = null;
            if (log == null)
            {
                // aqui chama a o arquivo de execução que é na verdade a classe
                log = new CriarArquivoLog();  // vai para -> private ImplementationClass();
                retorno += "\n Não Existe e Criou o Arquivo: ";
// metodo de gravar o log;
                return retorno;
            }
            else
            {
// aqui o metodo de gravar o log;
                retorno += "Existe o Arquivo: ";
                return retorno;
            }
            retorno += "\n Aconceteu algum erro ";
            return retorno;
        }
        private CriarArquivoLog()
        {  // construtor.  privado.
            try
            {
                MessageBox.Show("criando arquivo: " + path);
                this.arquivo = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.Write);
                arquivo.Close();
            }
            catch (Exception error)
            {
                retorno += "\n " + error.Message;
                //return retorno;
            }
        }
    }

// Alguma duvida comente;