Muitos programadores já assinaram uma interface para criar alguma
classe para uma especifica função, já existe no próprio namespace System
algumas intefaces, por exemplo: System.IAppDomainSetup, System.IAsyncResult e
System.IServiceProvider, você pode ter visto a utilização delas em algum
exemplo ou mesmo utilizado.
Mas a questão é bem simples... Você sabe descrever o que é uma interface e/ou quais são suas utilidades e importâncias que ela tem na vida de um sistema, tanto a curto como em longo prazo?
Muito bem, se não sabe este artigo vai de ajudar e esse já sabe vale a pena conferir, pois sempre temo algo a aprender.
Primeiro vamos à definição: Interface pode conter apenas assinaturas de eventos, métodos, propriedades e indexadores.
Segundo, interfaces são contratos, a única regra que o contratante tem que seguir é implementar todos os membros da interface de forma a seguir as assinaturas dos mesmos.
Isso quer disser que: Se uma classe contrata (implementa) a interface System.IAsyncResult essa classe fica obrigada a implementar as quatro propriedades que há nesta interface.
Vamos ao exemplo:
namespace System
{
public interface IAsyncResult
{
object AsyncState { get; }
System.Threading.WaitHandle AsyncWaitHandle { get; }
bool CompletedSynchronously { get; }
bool IsCompleted { get; }
}
}
Esse é o código da interface, onde tem a assinatura de quatro propriedades, e essas propriedades deve ter obrigatoriamente o método get. OBS: Não precisa criar este bloco, eu apenas colei aqui para ficar mais fácil de observar a interface.
class AsyncResultExeplo : System.IAsyncResult
{
#region IAsyncResult Members
private object _AsyncState;
public object AsyncState
{
get { return _AsyncState; }
}
private System.Threading.WaitHandle _AsyncWaitHandle;
public System.Threading.WaitHandle AsyncWaitHandle
{
get { return _AsyncWaitHandle; }
}
private bool _CompletedSynchronously;
public bool CompletedSynchronously
{
get { return _CompletedSynchronously; }
}
private bool _IsCompleted;
public bool IsCompleted
{
get { return _IsCompleted; }
}
#endregion
}
E essa é uma classe bem resumida, mas assinando o contrato com a interface e cumprindo sua parte de implementar tudo que a interface assina.
Outro ponto importante, podemos assinar mais de uma interface por classe, com isso teremos que contratar mais de uma interface e cumprir todas as exigências de cada interface.
Continuando o exemplo:
namespace System
{
public interface IFormattable
{
string ToString(string format, IFormatProvider formatProvider);
}
}
Esta é mais uma interface do namespace System, e essa interface tem apenas a assinatura de um método. OBS: Não precisa criar este bloco, eu apenas colei aqui para ficar mais fácil de observar a interface.
class AsyncResultExeplo : System.IAsyncResult, System.IFormattable
{
#region IAsyncResult Members
private object _AsyncState;
public object AsyncState
{
get { return _AsyncState; }
}
private System.Threading.WaitHandle _AsyncWaitHandle;
public System.Threading.WaitHandle AsyncWaitHandle
{
get { return _AsyncWaitHandle; }
}
private bool _CompletedSynchronously;
public bool CompletedSynchronously
{
get { return _CompletedSynchronously; }
}
private bool _IsCompleted;
public bool IsCompleted
{
get { return _IsCompleted; }
}
#endregion
#region IFormattable Members
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format(formatProvider, format, "Teste");
}
#endregion
}
Agora nossa classe esta assinando (implementando) e interfaces e cumprindo todas as regras de ambas, observe que separamos as interfaces por vírgula, outro ponto importante é caso exista a necessidade de herdar de outra classe essa deve vir logo após o”:” e em seguida separados por vírgula”,” as interfaces, lembrando que não existem múltiplas heranças mas existe múltiplas assinaturas de interfance.
Legal, e o que ganhamos com as interfaces? Neste exemplo podemos passar nossa classe para qualquer método ou propriedade que sejam do tipo de um das interfaces, por exemplo um método que espera um System.IAsyncResult, vamos criar um método que espera um objeto System.IAsyncResult e você verá que poderemos chamar qualquer membro da interface que o objeto implementou.
static void Teste(System.IAsyncResult ar)
{
Console.WriteLine("AsyncState: {0}", ar.AsyncState);
Console.WriteLine("CompletedSynchronously: {0}", ar.CompletedSynchronously);
Console.WriteLine("IsCompleted: {0}", ar.IsCompleted);
}
Estamos recebendo um objeto que implementa a interface System.IAsyncResult e pela invocação dos membros dessa interface pegamos os valores desse objeto, outra forma e um pouco complicado seria receber um “object” e por meio de reflexão acessar os membros da classe, isso deixaria o nosso código pouco confiável, caso precisássemos sempre do “IsCompleted” e recebido como parâmetro uma classe que não tem essa propriedade vai dar erro ou teríamos que tratar, utilizando interface como parâmetros garantimos que a classe assinou a mesma e portanto temos esse membro na classe.
Depois de termo visto as duas primeiras importâncias e um pouco da terceira que será exposto agora, já podemos ver que as interfaces são muito úteis para a vida de um sistema.
O terceiro ponto é: Quando precisamos garantir a existência de algum método, propriedade, evento ou indexadores e vamos ter um grupo de classe com esse mesmo aspecto e com o passar do tempo serão criadas outras classes com o mesmo intuito as interfaces serão a garantia que todos e tudo fiquem no padrão para os métodos que essas classes serão fornecidas como parâmetro funcione bem.
Bom, chegamos ao fim desse artigo, logo estarei com mais uma parte onde mostrarei outro uso para interfaces e criaremos a nossa interface para o próximo artigo.
Até a próxima, ahh não se esqueçam de fazer o download do exemplo.
