Polymorphism (guia de programação C#)

Artigo
08/25/2010

Polimorfismo é conhecido sistema autônomo o terceiro pilar da programação orientada a objeto, após o encapsulamento e herança.Polimorfismo é uma palavra grega significa "em forma muitos" e tem dois aspectos distintos:

Em time de execução, objetos de uma classe derivada podem ser tratados sistema autônomo objetos de uma classe base em locais sistema autônomo parâmetros de método e coleções ou matrizes.Quando isso ocorre, o objeto do declarado tipo não é idêntico ao seu em time de execução tipo.
Base classes may define and implement virtualmethods, and derived classes can override them, which means they provide their own definition and implementation.Em time de execução quando o código do cliente chama o método, o CLR procura o tipo de time de execução do objeto e chama a substituir do método virtual.Assim, em seu código-fonte pode chamar um método na classe base e fazer com que versão uma classe derivada do método a ser executado.

Métodos virtual permitem que você trabalhar com grupos de objetos relacionados de maneira uniforme.Por exemplo, suponha que você tenha um aplicativo de desenho que permite que um usuário criar vários tipos de formas em uma superfície de desenho.Você não souber em time de compilar que tipos específicos de formas o usuário será criar.No entanto, o aplicativo tem que manter o controle de todos os diversos tipos de formas que são criados e ele deve atualizá-los em resposta a ações de mouse do usuário.Você pode usar polimorfismo para solucionar esse problema em duas etapas básicas:

criar uma hierarquia de classes em que cada classe de forma específica deriva de uma classe base comum.
Use um método virtual para invocar o método apropriado em qualquer classe derivada por meio de uma única telefonar para o método da classe base.

Primeiro, crie uma classe base chamada Shapee classes derivadas sistema autônomo Rectangle, Circle, e Triangle. Dar o Shape um método virtual chamado de classe Draw, e substituir em cada classe derivada para desenhar particular que forma a classe representa. Criar um List<Shape> objeto e adicionar um círculo e triângulo retângulo a ele. Para atualizar a superfície de desenho, use um foreach loop para iterar através da lista e telefonar o Draw método em cada Shape objeto da lista. Embora cada objeto da lista tem o tipo declarado de Shape, é o tipo de time de execução (a versão substituída do método em cada classe derivada) que será chamado.

public class Shape
{
    // A few example members
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Height { get; set; }
    public int Width { get; set; }

    // Virtual method
    public virtual void Draw()
    {
        Console.WriteLine("Performing base class drawing tasks");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        // Code to draw a circle...
        Console.WriteLine("Drawing a circle");
        base.Draw();
    }
}
class Rectangle : Shape
{
    public override void Draw()
    {
        // Code to draw a rectangle...
        Console.WriteLine("Drawing a rectangle");
        base.Draw();
    }
}
class Triangle : Shape
{
    public override void Draw()
    {
        // Code to draw a triangle...
        Console.WriteLine("Drawing a triangle");
        base.Draw();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Polymorphism at work #1: a Rectangle, Triangle and Circle
        // can all be used whereever a Shape is expected. No cast is
        // required because an implicit conversion exists from a derived 
        // class to its base class.
        System.Collections.Generic.List<Shape> shapes = new System.Collections.Generic.List<Shape>();
        shapes.Add(new Rectangle());
        shapes.Add(new Triangle());
        shapes.Add(new Circle());

        // Polymorphism at work #2: the virtual method Draw is
        // invoked on each of the derived classes, not the base class.
        foreach (Shape s in shapes)
        {
            s.Draw();
        }

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

}

/* Output:
    Drawing a rectangle
    Performing base class drawing tasks
    Drawing a triangle
    Performing base class drawing tasks
    Drawing a circle
    Performing base class drawing tasks
 */

Em translation from VPE for Csharp, todos os tipos é polimórfico porque todos os tipos, incluindo tipos definidos pelo usuário, herdam Object.

Visão geral de polimorfismo

Membros virtual

Quando uma classe derivada herda de uma classe base, obtém todos os métodos, campos, propriedades e eventos da classe base.O designer da classe derivada pode escolher se deseja

Substituir membros virtual na classe base,
herdar o método mais próximo da classe base sem substituição-
Definir nova implementação não-virtual desses membros ocultar as implementações de classe base

Uma classe derivada pode substituir um membro da classe base somente se o membro de classe base é declarado sistema autônomo virtual orResumo.O membro derivado deve usar o Substituir palavra-chave para indicar explicitamente que o método deve participar de chamada virtual.O código a seguir é um exemplo:

public class BaseClass
{
    public virtual void DoWork() { }
    public virtual int WorkProperty
    {
        get { return 0; }
    }
}
public class DerivedClass : BaseClass
{
    public override void DoWork() { }
    public override int WorkProperty
    {
        get { return 0; }
    }
}

Os campos não podem ser virtual; somente métodos, propriedades, eventos e os indexadores podem ser virtual.Quando uma classe derivada substitui um membro virtual, esse membro é chamado, mesmo quando uma instância da classe que está sendo acessada sistema autônomo uma instância da classe base.O código a seguir é um exemplo:

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Also calls the new method.

Propriedades e métodos virtual permitem classes derivadas estender uma classe base sem precisar usar a implementação da classe base de um método.Para obter mais informações, consulte Versão com o substituição e palavras-chave new (guia de programação C#) .Uma interface é outra forma para definir um método ou um conjunto de métodos cuja implementação é da esquerda para classes derivadas.Para obter mais informações, consulte Interfaces (guia de programação C#) e Escolhendo entre classes e interfaces.

Ocultar membros de classe de base com novos membros

Se desejar que seu membro derivado para ter o mesmo nome sistema autônomo um membro em uma classe base, mas você não deseje que ele participe de chamada virtual, você pode usar o novo palavra-chave.The new palavra-chave é colocado antes do tipo de retorno de um membro da classe que está sendo substituído. O código a seguir é um exemplo:

public class BaseClass
{
    public void DoWork() { WorkField++; }
    public int WorkField;
    public int WorkProperty
    {
        get { return 0; }
    }
}

public class DerivedClass : BaseClass
{
    public new void DoWork() { WorkField++; }
    public new int WorkField;
    public new int WorkProperty
    {
        get { return 0; }
    }
}

Membros da classe base oculto ainda podem ser acessados do código de cliente a instância da classe a uma instância da classe base derivada de projeção.Por exemplo:

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Calls the old method.

Impedindo a classes derivadas substituindo membros virtual

Membros virtuais permanecem indefinidamente, independentemente de quantas classes foram declarados entre o membro virtual e a classe que originalmente declarado como virtuais.A se classe A declara um membro virtual, classe B deriva de um e classe que C deriva de B, C classe herda membro virtual e tem a opção para substituí-la, independentemente de se classe B declarado uma substituir para esse membro.O código a seguir é um exemplo:

public class A
{
    public virtual void DoWork() { }
}
public class B : A
{
    public override void DoWork() { }
}

Uma classe derivada pode impedir herança virtual declarando uma substituir sistema autônomo selado.Isso requer colocando o sealed palavra-chave antes da override palavra-chave na declaração de membro da classe. O código a seguir é um exemplo:

public class C : B
{
    public sealed override void DoWork() { }
}

No exemplo anterior, o método DoWork não é mais virtual para qualquer classe derivada de C. É ainda virtual para instâncias de C, mesmo se eles são convertidos em tipo B ou a. tipoLacrado métodos podem ser substituídos por classes derivadas, usando o new palavra-chave, sistema autônomo mostra o exemplo a seguir:

public class D : C
{
    public new void DoWork() { }
}

Nesse caso, se DoWork é chamado em D usando uma variável do tipo D, o novo DoWork é chamado. Se for usada para uma variável do tipo C, B ou A acesso uma instância de D, uma telefonar para DoWork seguirá as regras de herança virtual, as chamadas para a implementação de roteamento DoWork na classe C.

Acessando classe base virtual de membros de classes derivadas

Uma classe derivada que tenha substituído ou substituído um método ou propriedade ainda pode acessar o método ou propriedade na classe base usando a palavra-chave base.O código a seguir é um exemplo:

public class Base
{
    public virtual void DoWork() {/*...*/ }
}
public class Derived : Base
{
    public override void DoWork()
    {
        //Perform Derived's work here
        //...
        // Call DoWork on base class
        base.DoWork();
    }
}

Para obter mais informações, consulte Base.

Observação:
É recomendável que usem membros virtual base para chamar a implementação da classe base desse membro em sua própria implementação. Permitindo que o comportamento da classe base ocorrem permite que a classe derivada para se concentrar na implementação de comportamento específico para a classe derivada.Se a implementação da classe base não for chamada, ele é a classe derivada para tornar seu comportamento compatível com o comportamento da classe base.

É recomendável que usem membros virtual base para chamar a implementação da classe base desse membro em sua própria implementação. Permitindo que o comportamento da classe base ocorrem permite que a classe derivada para se concentrar na implementação de comportamento específico para a classe derivada.Se a implementação da classe base não for chamada, ele é a classe derivada para tornar seu comportamento compatível com o comportamento da classe base.