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;