Instanciando Interfaces em C #?

4
Estou lendo / aprendendo sobre interfaces em C # no momento, e até agora consegui entender como isso difere de uma classe abstrata. No livro que estou lendo, o autor explica que as interfaces são a última classe abstrata e que ela simplesmente define o padrão de certos métodos que a classe herdadora terá, mas depois fornece o seguinte exemplo.

static void Main(string[] args)
{
...
Circle c = new Circle("Lisa");
IPointy itPt = null;
try
{
itPt = (IPointy)c;
Console.WriteLine.(itPt.Points);
}
catch (InvalidCastException e)
{
 Console.WriteLine(e.Message);
}
...
}

A linha que absolutamente me joga fora é o IPointy itfPt=null; que ele acabou de declarar uma interface? Eu pensei que as interfaces são abstratas e só podem ser herdadas? Que tipo de feitiçaria está acontecendo aqui?

    
por RealityDysfunction 07.10.2012 / 01:54
fonte

4 respostas

11

Esse exemplo demonstra uma tentativa ... pegar mais do que tudo.

Interfaces são tipos também .. mas eles apenas expõem seu contrato. Então isso:

IPointy itPt = new IPointy();

.. não funciona. Considere isto:

interface IPointy {
    void MyMethod();
}

class Pencil : IPointy {
    void MyMethod() {
    }

    void MyOtherMethod() {
    }
}

Você pode declarar um IPointy assim:

IPointy itPt = new Pencil();

.. no entanto, isso funcionará:

itPt.MyMethod();

.. isso não funcionará:

itPt.MyOtherMethod();

Isso ocorre porque MyMethod faz parte do contrato IPointy .. MyOtherMethod não é .. Espero que ajude.

EDIT: Expandindo isso para explicar meu comentário.

Herdar de uma classe representa um relacionamento "é-um". A implementação de uma interface representa um relacionamento "posso fazer".

Considere:

interface ISwitchable {
    void SwitchOn();
    void SwitchOff();
}

class Light : ISwitchable {
    void SwitchOn() { }
    void SwitchOff() { }
}

class Television : ISwitchable {
    void SwitchOn() { }
    void SwitchOff() { }
}

Tanto a televisão quanto a luz são herdadas da ISwitchable. A interface define um relacionamento "pode fazer". Ambos podem ser ativados ou desativados. Ambos os seguintes blocos de código são válidos:

ISwitchable mySwitchableObject1 = new Light();
ISwitchable mySwitchableObject2 = new Television();

mySwitchableObject1.SwitchOn(); // calls Light's SwitchOn method
mySwitchableObject2.SwitchOn(); // calls Television's SwitchOn method
    
por 07.10.2012 / 02:10
fonte
2

Você pode declarar variáveis digitadas como interfaces: isso não equivale a instanciar elas. Depois de declarar uma variável do tipo de interface, você pode atribuir a ela um objeto da classe any que implementa a interface.

Por exemplo, você pode declarar uma variável do tipo de interface IDictionary<string,string> , mas não pode instanciá-la: você deve escolher uma classe que implemente IDictionary<string,string> , por exemplo

IDictionary<string,string> d = new Dictionary<string,string>();

ou

IDictionary<string,string> d = new SortedList<string,string>();
    
por 07.10.2012 / 02:14
fonte
1

Uma interface é declarada usando a palavra-chave interface, que essa linha de código não contém.

O que você está vendo é uma declaração de variável, uma variável chamada itfPt, cujo tipo é IPointy. A variável obtém o valor 'null', que não é uma instância.

Instanciando a interface IPointy não é possível, você pode tentar fazê-lo através do tipo itfPt = new IPointy (); e examinando os erros de compilação. Os únicos valores que podem ser atribuídos a itfPt são instâncias de subtipos concretos de IPointy e null.

    
por 07.10.2012 / 02:01
fonte
1

Acho que o que você procura é instanciação da Interface e uso dela. Aqui está um exemplo que pode ajudá-lo:

public interface IFoo
{
    void Bar1();
    void Bar2();
}

public Class ActionableFoo : IFoo
{
    Action _bar1, _bar2;

    public ActionableFoo(Action b1, Action b2)
    {
        _bar1 = b1;
        _bar2 = b2;
    }

    public void Bar1() { if(_bar1 != null) _bar1(); }
    public void Bar2() { if(_bar2 != null) _bar2(); }
}

public void PushFoo(Action bar1, Action bar2)
{
    IFoo foo = new ActionableFoo(bar1, bar2);
    _fooStack.Push(foo);
}
    
por 07.10.2012 / 02:08
fonte

Tags