virtual (Referência de C#)virtual (C# Reference)

A palavra-chave virtual é usada para modificar uma declaração de método, propriedade, indexador ou evento e permitir que ela seja substituída em uma classe derivada.The virtual keyword is used to modify a method, property, indexer, or event declaration and allow for it to be overridden in a derived class. Por exemplo, esse método pode ser substituído por qualquer classe que o herde:For example, this method can be overridden by any class that inherits it:

public virtual double Area() 
{
    return x * y;
}

A implementação de um membro virtual pode ser alterada por um membro de substituição em uma classe derivada.The implementation of a virtual member can be changed by an overriding member in a derived class. Para obter mais informações sobre como usar a palavra-chave virtual, consulte Controle de versão com as palavras-chave override e new e Quando usar as palavras-chave override e new.For more information about how to use the virtual keyword, see Versioning with the Override and New Keywords and Knowing When to Use Override and New Keywords.

ComentáriosRemarks

Quando um método virtual é invocado, o tipo de tempo de execução do objeto é verificado para um membro de substituição.When a virtual method is invoked, the run-time type of the object is checked for an overriding member. O membro de substituição na classe mais derivada é chamado, que pode ser o membro original, se nenhuma classe derivada tiver substituído o membro.The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member.

Por padrão, os métodos não são virtuais.By default, methods are non-virtual. Você não pode substituir um método não virtual.You cannot override a non-virtual method.

Não é possível usar o modificador virtual com os modificadores static, abstract, private ou override.You cannot use the virtual modifier with the static, abstract, private, or override modifiers. O exemplo a seguir mostra uma propriedade virtual:The following example shows a virtual property:

class MyBaseClass
{
    // virtual auto-implemented property. Overrides can only
    // provide specialized behavior if they implement get and set accessors.
    public virtual string Name { get; set; }

    // ordinary virtual property with backing field
    private int num;
    public virtual int Number
    {
        get { return num; }
        set { num = value; }
    }
}

class MyDerivedClass : MyBaseClass
{
    private string name;

   // Override auto-implemented property with ordinary property
   // to provide specialized accessor behavior.
    public override string Name
    {
        get
        {
            return name;
        }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                name = value;
            }
            else
            {
                name = "Unknown";
            }
        }
    } 
}

Propriedades virtuais se comportam como métodos abstratos, exceto pelas diferenças na sintaxe de declaração e chamada.Virtual properties behave like abstract methods, except for the differences in declaration and invocation syntax.

  • É um erro usar o modificador virtual em uma propriedade estática.It is an error to use the virtual modifier on a static property.

  • Uma propriedade herdada virtual pode ser substituída em uma classe derivada incluindo uma declaração de propriedade que usa o modificador override.A virtual inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

ExemploExample

Neste exemplo, a classe Shape contém as duas coordenadas x, y e o método virtual Area().In this example, the Shape class contains the two coordinates x, y, and the Area() virtual method. Classes de forma diferentes como Circle, Cylinder e Sphere herdam a classe Shape e a área de superfície é calculada para cada figura.Different shape classes such as Circle, Cylinder, and Sphere inherit the Shape class, and the surface area is calculated for each figure. Cada classe derivada tem a própria implementação de substituição do Area().Each derived class has its own override implementation of Area().

Observe que as classes herdadas Circle, Sphere e Cylinder usam construtores que inicializam a classe base, conforme mostrado na declaração a seguir.Notice that the inherited classes Circle, Sphere, and Cylinder all use constructors that initialize the base class, as shown in the following declaration.

public Cylinder(double r, double h): base(r, h) {}

O programa a seguir calcula e exibe a área apropriada para cada figura invocando a implementação apropriada do método Area(), de acordo com o objeto que está associado ao método.The following program calculates and displays the appropriate area for each figure by invoking the appropriate implementation of the Area() method, according to the object that is associated with the method.

class TestClass
{
    public class Shape
    {
        public const double PI = Math.PI;
        protected double x, y;
        
        public Shape()
        {
        }
        
        public Shape(double x, double y)
        {
            this.x = x;
            this.y = y;
        }

        public virtual double Area()
        {
            return x * y;
        }
    }

    public class Circle : Shape
    {
        public Circle(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return PI * x * x;
        }
    }

    class Sphere : Shape
    {
        public Sphere(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return 4 * PI * x * x;
        }
    }

    class Cylinder : Shape
    {
        public Cylinder(double r, double h) : base(r, h)
        {
        }

        public override double Area()
        {
            return 2 * PI * x * x + 2 * PI * x * y;
        }
    }

    static void Main()
    {
        double r = 3.0, h = 5.0;
        Shape c = new Circle(r);
        Shape s = new Sphere(r);
        Shape l = new Cylinder(r, h);
        // Display results:
        Console.WriteLine("Area of Circle   = {0:F2}", c.Area());
        Console.WriteLine("Area of Sphere   = {0:F2}", s.Area());
        Console.WriteLine("Area of Cylinder = {0:F2}", l.Area());
    }
}
/*
Output:
Area of Circle   = 28.27
Area of Sphere   = 113.10
Area of Cylinder = 150.80
*/

Especificação da linguagem C#C# language specification

Para obter mais informações, consulte a Especificação da linguagem C#.For more information, see the C# Language Specification. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.The language specification is the definitive source for C# syntax and usage.

Consulte tambémSee also