Compartilhar via

virtual (Referência de C#)

Use a virtual palavra-chave para modificar um método, propriedade, indexador ou declaração de evento e permitir que uma classe derivada a substitua.

A linguagem C# faz referência a documentos da versão mais recentemente lançada da linguagem C#. Ele também contém a documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento do idioma.

A documentação identifica qualquer recurso introduzido pela primeira vez nas três últimas versões do idioma ou nas versões prévias públicas atuais.

Dica

Para descobrir quando um recurso foi introduzido pela primeira vez em C#, consulte o artigo sobre o histórico de versão da linguagem C#.

Por exemplo, qualquer classe que herda esse método pode substituí-lo:

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

Um membro que substitui em uma classe derivada pode alterar a implementação de um membro virtual. 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.

Quando você invoca um método virtual, o runtime verifica o tipo do objeto para um membro que substitui. Ele chama o membro que substitui na classe mais derivada. Se nenhuma classe derivada substituir o membro, o membro original será chamado.

Por padrão, os métodos não são virtuais. Você não pode substituir um método não virtual.

O exemplo a seguir mostra uma propriedade virtual:

class MyBaseClass
{
    // virtual automatically 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 automatically 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 virtuais, exceto pelas diferenças na sintaxe de declaração e chamada.

  • Uma propriedade herdada virtual pode ser substituída em uma classe derivada incluindo uma declaração de propriedade que usa o modificador override.

Exemplo

Neste exemplo, a Shape classe contém as duas coordenadas x e yo Area() método virtual. Classes de forma diferentes como Circle, Cylinder e Sphere herdam a classe Shape e a área de superfície é calculada para cada figura. Cada classe derivada tem a própria implementação de substituição do Area().

As classes CircleCylinderherdadas e Sphere todos usam construtores que inicializam a classe base, conforme mostrado na declaração a seguir.

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.

class TestClass
{
    public class Shape
    {
        public const double PI = Math.PI;
        protected double _x, _y;

        public Shape()
        {
        }

        public Shape(double x, double y)
        {
            _x = x;
            _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;
        }
    }

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

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

    public 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   = {c.Area():F2}");
        Console.WriteLine($"Area of Sphere   = {s.Area():F2}");
        Console.WriteLine($"Area of Cylinder = {l.Area():F2}");
    }
}
/*
Output:
Area of Circle   = 28.27
Area of Sphere   = 113.10
Area of Cylinder = 150.80
*/

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Confira também

  • Last updated on