nova palavra em interfaces em c #

votos
3
using System;

namespace random

{

    interface IHelper
    {
        void HelpMeNow();
    }
    public class Base : IHelper
    {
        public void HelpMeNow()
        {
            Console.WriteLine(Base.HelpMeNow());
        }
    }
    public class Derived : Base
    {
        public new void HelpMeNow()            ///this line
        {
            Console.WriteLine(Derived.HelpMeNow());
        }
    }
    class Test
    {
        public static void Main()
        {
            Derived der = new Derived();
            der.HelpMeNow();
            IHelper helper = (IHelper)der;
            helper.HelpMeNow();
            Console.ReadLine();
        }
    }
}

a nova palavra-chave na linha comentada é um pouco confuso para mim. Ele jsut quer dizer que substitui a implementação do método na classe base. Por que não usar palavra-chave override?

Publicado 27/08/2009 em 01:01
fonte usuário
Em outras línguas...                            


3 respostas

votos
9

Veja este artigo no MSDN: Saber quando usar Substituir e novas palavras-chave

Respondeu 27/08/2009 em 01:03
fonte usuário

votos
0

Em geral, se a interface IBase implementa um membro DoSomething e IDerived herda / implementa Ibase, é esperado que IDerived.DoSomething será sinônimo de IBase.DoSomething. Em geral, isso é útil, uma vez que economiza implementadores da classe de ter que fornecer implementações redundantes. Há, no entanto, alguns casos em que uma interface derivada deve implementar um membro que tem o mesmo nome que um membro na interface de base, mas que terão de ser implementados separadamente. Os tais situações mais comuns são: (1) o método derivado irá ter um tipo de retorno diferente do tipo base, ou (2) da interface (s) de base implementa uma propriedade (s) só de leitura e / ou WriteOnly com um certo e o derivado tipo deve implementar uma propriedade Read-Write. Por alguma razão, se a interface IReadableFoo fornece uma propriedade só de leitura Foo, IWritableFoo fornece uma só de escrita propriedade Foo, e interface de IMutableFoo simplesmente herda tanto, o compilador não vai saber se uma referência ao Foo refere-se a IReadableFoo.Foo ou IWritableFoo. foo. Apesar de apenas IReadableFoo.Foo pode ser lido, e só IWritableFoo.Foo podem ser escritas nem vb.net nem C # pode resolver a sobrecarga a menos que se implementa uma nova propriedade de leitura e escrita Foo que lida com ambos.

Respondeu 24/07/2011 em 20:42
fonte usuário

votos
0

Não é realmente substituindo-lo, é sombreamento -lo. Dada uma referência a um Derivedobjeto, Base's HelpMeNowfunção não estará acessível 1 , e derivedObject.HelpMeNow()chamará Derived' s implementação.

Este não é o mesmo que substituir uma função virtual, o que HelpMeNownão é. Se um Derivedobjeto é armazenado em uma referência a uma Baseou a um IHelper, em seguida, Base's HelpMeNow()será chamado, e Derivedda implementação será inacessível.

Derived derivedReference = new Derived();
Base    baseReference    = derivedReference;
IHelper helperReference  = derivedReference;

derivedReference.HelpMeNow(); // outputs "Derived.HelpMeNow()"
baseReference.HelpMeNow();    // outputs "Base.HelpMeNow()"
helperReference.HelpMeNow();  // outputs "Base.HelpMeNow()"

Claro, se o acima não é o comportamento desejado, e geralmente não é, há duas possibilidades. Se você controlar Base, simplesmente mudar HelpMeNow()para virtual, e substituí-lo em Derivedvez de sombreamento-lo. Se você não controlar Base, então você pode pelo menos corrigi-lo no meio do caminho, por reimplementar IHelper, assim:

class Derived : Base, IHelper{
    public new void HelpMeNow(){Console.WriteLine("Derived.HelpMeNow()");}

    void IHelper.HelpMeNow(){HelpMeNow();}
}

Esta versão de Derivedusos que é chamado de implementação de interface explícita , que lhe permite satisfazer o contrato de implementação de uma interface sem adicionar a implementação para a interface pública da sua classe. Neste exemplo, nós já temos uma implementação na Derivedinterface pública 's que é herdado de Base, por isso temos de implementar explicitamente IHelperpara mudá-lo 2 . Neste exemplo, nós apenas encaminhar a implementação de IHelper.HelpMeNowà interface pública, que é a sombra do Base's.

Assim, com esta mudança, uma chamada para baseReference.HelpMeNow()ainda produz "Base.HelpMeNow ()", mas uma chamada para helperReference.HelpMeNow()agora será de saída "Derived.HelpMeNow ()". Não tão bom quanto mudando Baseimplementação 's para virtual, mas tão bom quanto nós vamos conseguir, se nós não controlamos Base.

Uma excepção: ele é acessível a partir de dentro de métodos Derived, mas apenas quando qualificados com base., tal como no base.HelpMeNow().
2 Note que nós também temos que declarar IHelpercomo uma interface os implementos de classe, mesmo que herdamos esta declaração do Base.

Respondeu 27/08/2009 em 01:33
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more