Megosztás a következőn keresztül:

virtuális (C# referencia)

  • Cikk

A virtual kulcsszó egy metódus, tulajdonság, indexelő vagy eseménydeklaráció módosítására szolgál, és lehetővé teszi, hogy felülbírálódjon egy származtatott osztályban. Ezt a metódust például felülírhatja bármely olyan osztály, amely örökli:

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

A virtuális tag implementálását egy származtatott osztály felülrendelő tagja módosíthatja. A kulcsszó használatáról további információt a virtual Felülbírálás és az Új kulcsszavak verziószámozása, valamint a felülbírálás és az új kulcsszavak használatának ismerete című témakörben talál.

Megjegyzések

Virtuális metódus meghívásakor a rendszer ellenőrzi az objektum futásidejű típusát egy felülíró tag esetében. A rendszer meghívja a legelterjedtebb osztály felülíró tagját, amely lehet az eredeti tag, ha egyetlen származtatott osztály sem bírálta felül a tagot.

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

A módosító nem használható a virtualstatic, abstract, private, vagy override módosítókkal. Az alábbi példa egy virtuális tulajdonságot mutat be:

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

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.

  • Hiba a módosító statikus tulajdonságon való használata virtual .

  • 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 xyés a 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. Minden származtatott osztály saját felülbírálási implementációval rendelkezik Area().

Figyelje meg, hogy 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   = {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
*/

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