Megosztás:

virtuális (C# referencia)

virtual A kulcsszóval módosíthat egy metódust, tulajdonságot, indexelőt vagy eseménydeklarációt, és engedélyezheti, hogy egy származtatott osztály felülbírálja azt.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

A metódust öröklő bármely osztály például felülbírálhatja azt:

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

Egy származtatott osztály felülíró tagja megváltoztathatja a virtuális tag implementációját. További információért a virtual kulcsszó használatáról lásd a következő fejezeteket: Verziószámozás a felülbírálás és új kulcsszavakkal, továbbá Mikor érdemes a felülbírálás és új kulcsszavakat használni.

Virtuális metódus meghívásakor a futtatókörnyezet ellenőrzi az objektum típusát egy felülíró tag számára. A legelterjedtebb osztály legfontosabb tagját hívja meg. Ha egyetlen származtatott osztály sem bírálja felül a tagot, a függvény meghívja az eredeti tagot.

Alapértelmezés szerint a metódusok nem virtuálisak. Nem lehet felülbírálni a nem virtuális metódusokat.

Az alábbi példa egy virtuális tulajdonságot mutat be:

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";
            }
        }
    }
}

A virtuális tulajdonságok a virtuális metódusokhoz hasonlóan viselkednek, kivéve a deklaráció és a hívás szintaxisának különbségeit.

  • A virtuális öröklődő tulajdonságot felül lehet bírálni egy származtatott osztályban egy módosítót használó override tulajdonságdeklarációval.

Példa

Ebben a példában az Shape osztály a két koordinátát x és ya virtuális metódust Area() tartalmazza. A különböző alakzatosztályok, például Circlea , Cylinderés Sphere öröklik az Shape osztályt, és a felület kiszámítása az egyes ábrákhoz történik. A származtatott osztályok mindegyike saját felülíró implementációval rendelkezik Area().

Az örökölt osztályok Circle, Cylinderés Sphere minden olyan konstruktort használ, amely inicializálja az alaposztályt az alábbi deklarációban látható módon.

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

Az alábbi program kiszámítja és megjeleníti a megfelelő területet az egyes ábrákhoz a metódus megfelelő implementációjának Area() meghívásával a metódushoz társított objektumnak megfelelően.

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
*/

C# nyelvspecifikáció

További információkért lásd a C# nyelvi specifikációját. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.

Lásd még

  • Last updated on